]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool 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_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",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_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
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_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxString *result = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 {
9883 wxString const &_result_ref = (arg1)->GetMimeType();
9884 result = (wxString *) &_result_ref;
9885 }
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 #if wxUSE_UNICODE
9891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9892 #else
9893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9894 #endif
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFSFile *arg1 = (wxFSFile *) 0 ;
9905 wxString *result = 0 ;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 {
9920 wxString const &_result_ref = (arg1)->GetLocation();
9921 result = (wxString *) &_result_ref;
9922 }
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 {
9927 #if wxUSE_UNICODE
9928 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9929 #else
9930 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9931 #endif
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxFSFile *arg1 = (wxFSFile *) 0 ;
9942 wxString *result = 0 ;
9943 void *argp1 = 0 ;
9944 int res1 = 0 ;
9945 PyObject *swig_obj[1] ;
9946
9947 if (!args) SWIG_fail;
9948 swig_obj[0] = args;
9949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9950 if (!SWIG_IsOK(res1)) {
9951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9952 }
9953 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 {
9957 wxString const &_result_ref = (arg1)->GetAnchor();
9958 result = (wxString *) &_result_ref;
9959 }
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 #if wxUSE_UNICODE
9965 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9966 #else
9967 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9968 #endif
9969 }
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxFSFile *arg1 = (wxFSFile *) 0 ;
9979 wxDateTime result;
9980 void *argp1 = 0 ;
9981 int res1 = 0 ;
9982 PyObject *swig_obj[1] ;
9983
9984 if (!args) SWIG_fail;
9985 swig_obj[0] = args;
9986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9989 }
9990 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetModificationTime();
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *obj;
10006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10007 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10008 return SWIG_Py_Void();
10009 }
10010
10011 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10012 return SWIG_Python_InitShadowInstance(args);
10013 }
10014
10015 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *resultobj = 0;
10017 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 PyObject *swig_obj[1] ;
10021
10022 if (!args) SWIG_fail;
10023 swig_obj[0] = args;
10024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10029 {
10030 PyThreadState* __tstate = wxPyBeginAllowThreads();
10031 delete arg1;
10032
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *obj;
10045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10046 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10047 return SWIG_Py_Void();
10048 }
10049
10050 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10051 PyObject *resultobj = 0;
10052 wxPyFileSystemHandler *result = 0 ;
10053
10054 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10071 PyObject *arg2 = (PyObject *) 0 ;
10072 PyObject *arg3 = (PyObject *) 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 PyObject * obj2 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "self",(char *) "_class", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10086 }
10087 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10088 arg2 = obj1;
10089 arg3 = obj2;
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 (arg1)->_setCallbackInfo(arg2,arg3);
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10106 wxString *arg2 = 0 ;
10107 bool result;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "self",(char *) "location", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10119 if (!SWIG_IsOK(res1)) {
10120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10121 }
10122 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10123 {
10124 arg2 = wxString_in_helper(obj1);
10125 if (arg2 == NULL) SWIG_fail;
10126 temp2 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 {
10135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10136 }
10137 {
10138 if (temp2)
10139 delete arg2;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = 0;
10153 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10154 wxFileSystem *arg2 = 0 ;
10155 wxString *arg3 = 0 ;
10156 wxFSFile *result = 0 ;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 void *argp2 = 0 ;
10160 int res2 = 0 ;
10161 bool temp3 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 PyObject * obj2 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "fs",(char *) "location", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10178 }
10179 if (!argp2) {
10180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10181 }
10182 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10183 {
10184 arg3 = wxString_in_helper(obj2);
10185 if (arg3 == NULL) SWIG_fail;
10186 temp3 = true;
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10196 }
10197 {
10198 if (temp3)
10199 delete arg3;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp3)
10205 delete arg3;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10214 wxString *arg2 = 0 ;
10215 int arg3 = (int) 0 ;
10216 wxString result;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 bool temp2 = false ;
10220 int val3 ;
10221 int ecode3 = 0 ;
10222 PyObject * obj0 = 0 ;
10223 PyObject * obj1 = 0 ;
10224 PyObject * obj2 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "spec",(char *) "flags", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10233 }
10234 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10235 {
10236 arg2 = wxString_in_helper(obj1);
10237 if (arg2 == NULL) SWIG_fail;
10238 temp2 = true;
10239 }
10240 if (obj2) {
10241 ecode3 = SWIG_AsVal_int(obj2, &val3);
10242 if (!SWIG_IsOK(ecode3)) {
10243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10244 }
10245 arg3 = static_cast< int >(val3);
10246 }
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 {
10254 #if wxUSE_UNICODE
10255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10256 #else
10257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10258 #endif
10259 }
10260 {
10261 if (temp2)
10262 delete arg2;
10263 }
10264 return resultobj;
10265 fail:
10266 {
10267 if (temp2)
10268 delete arg2;
10269 }
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 PyObject *resultobj = 0;
10276 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10277 wxString result;
10278 void *argp1 = 0 ;
10279 int res1 = 0 ;
10280 PyObject *swig_obj[1] ;
10281
10282 if (!args) SWIG_fail;
10283 swig_obj[0] = args;
10284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10285 if (!SWIG_IsOK(res1)) {
10286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10287 }
10288 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10289 {
10290 PyThreadState* __tstate = wxPyBeginAllowThreads();
10291 result = (arg1)->FindNext();
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 {
10296 #if wxUSE_UNICODE
10297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10298 #else
10299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10300 #endif
10301 }
10302 return resultobj;
10303 fail:
10304 return NULL;
10305 }
10306
10307
10308 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10309 PyObject *resultobj = 0;
10310 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10311 wxString *arg2 = 0 ;
10312 wxString result;
10313 void *argp1 = 0 ;
10314 int res1 = 0 ;
10315 bool temp2 = false ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 char * kwnames[] = {
10319 (char *) "self",(char *) "location", NULL
10320 };
10321
10322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10324 if (!SWIG_IsOK(res1)) {
10325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10326 }
10327 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10328 {
10329 arg2 = wxString_in_helper(obj1);
10330 if (arg2 == NULL) SWIG_fail;
10331 temp2 = true;
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (arg1)->GetProtocol((wxString const &)*arg2);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 #if wxUSE_UNICODE
10341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10342 #else
10343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10344 #endif
10345 }
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp2)
10354 delete arg2;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj = 0;
10362 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10363 wxString *arg2 = 0 ;
10364 wxString result;
10365 void *argp1 = 0 ;
10366 int res1 = 0 ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "location", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10378 }
10379 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10380 {
10381 arg2 = wxString_in_helper(obj1);
10382 if (arg2 == NULL) SWIG_fail;
10383 temp2 = true;
10384 }
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10388 wxPyEndAllowThreads(__tstate);
10389 if (PyErr_Occurred()) SWIG_fail;
10390 }
10391 {
10392 #if wxUSE_UNICODE
10393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10394 #else
10395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10396 #endif
10397 }
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return resultobj;
10403 fail:
10404 {
10405 if (temp2)
10406 delete arg2;
10407 }
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = 0;
10414 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10415 wxString *arg2 = 0 ;
10416 wxString result;
10417 void *argp1 = 0 ;
10418 int res1 = 0 ;
10419 bool temp2 = false ;
10420 PyObject * obj0 = 0 ;
10421 PyObject * obj1 = 0 ;
10422 char * kwnames[] = {
10423 (char *) "self",(char *) "location", NULL
10424 };
10425
10426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10428 if (!SWIG_IsOK(res1)) {
10429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10430 }
10431 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10432 {
10433 arg2 = wxString_in_helper(obj1);
10434 if (arg2 == NULL) SWIG_fail;
10435 temp2 = true;
10436 }
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (arg1)->GetAnchor((wxString const &)*arg2);
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 {
10444 #if wxUSE_UNICODE
10445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10446 #else
10447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10448 #endif
10449 }
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return resultobj;
10455 fail:
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj = 0;
10466 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10467 wxString *arg2 = 0 ;
10468 wxString result;
10469 void *argp1 = 0 ;
10470 int res1 = 0 ;
10471 bool temp2 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 char * kwnames[] = {
10475 (char *) "self",(char *) "location", NULL
10476 };
10477
10478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10484 {
10485 arg2 = wxString_in_helper(obj1);
10486 if (arg2 == NULL) SWIG_fail;
10487 temp2 = true;
10488 }
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 #if wxUSE_UNICODE
10497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10498 #else
10499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10500 #endif
10501 }
10502 {
10503 if (temp2)
10504 delete arg2;
10505 }
10506 return resultobj;
10507 fail:
10508 {
10509 if (temp2)
10510 delete arg2;
10511 }
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj = 0;
10518 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10519 wxString *arg2 = 0 ;
10520 wxString result;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 bool temp2 = false ;
10524 PyObject * obj0 = 0 ;
10525 PyObject * obj1 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "location", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 {
10548 #if wxUSE_UNICODE
10549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10550 #else
10551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10552 #endif
10553 }
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *obj;
10570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10572 return SWIG_Py_Void();
10573 }
10574
10575 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 return SWIG_Python_InitShadowInstance(args);
10577 }
10578
10579 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxFileSystem *result = 0 ;
10582
10583 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxFileSystem *)new wxFileSystem();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10600 PyObject *resultobj = 0;
10601 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10611 }
10612 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 delete arg1;
10616
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 resultobj = SWIG_Py_Void();
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj = 0;
10629 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10630 wxString *arg2 = 0 ;
10631 bool arg3 = (bool) false ;
10632 void *argp1 = 0 ;
10633 int res1 = 0 ;
10634 bool temp2 = false ;
10635 bool val3 ;
10636 int ecode3 = 0 ;
10637 PyObject * obj0 = 0 ;
10638 PyObject * obj1 = 0 ;
10639 PyObject * obj2 = 0 ;
10640 char * kwnames[] = {
10641 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10642 };
10643
10644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10648 }
10649 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10650 {
10651 arg2 = wxString_in_helper(obj1);
10652 if (arg2 == NULL) SWIG_fail;
10653 temp2 = true;
10654 }
10655 if (obj2) {
10656 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10657 if (!SWIG_IsOK(ecode3)) {
10658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10659 }
10660 arg3 = static_cast< bool >(val3);
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_Py_Void();
10669 {
10670 if (temp2)
10671 delete arg2;
10672 }
10673 return resultobj;
10674 fail:
10675 {
10676 if (temp2)
10677 delete arg2;
10678 }
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684 PyObject *resultobj = 0;
10685 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10686 wxString result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 PyObject *swig_obj[1] ;
10690
10691 if (!args) SWIG_fail;
10692 swig_obj[0] = args;
10693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10696 }
10697 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = (arg1)->GetPath();
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 {
10705 #if wxUSE_UNICODE
10706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10707 #else
10708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10709 #endif
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj = 0;
10719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10720 wxString *arg2 = 0 ;
10721 wxFSFile *result = 0 ;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 bool temp2 = false ;
10725 PyObject * obj0 = 0 ;
10726 PyObject * obj1 = 0 ;
10727 char * kwnames[] = {
10728 (char *) "self",(char *) "location", NULL
10729 };
10730
10731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10735 }
10736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10737 {
10738 arg2 = wxString_in_helper(obj1);
10739 if (arg2 == NULL) SWIG_fail;
10740 temp2 = true;
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10750 }
10751 {
10752 if (temp2)
10753 delete arg2;
10754 }
10755 return resultobj;
10756 fail:
10757 {
10758 if (temp2)
10759 delete arg2;
10760 }
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj = 0;
10767 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10768 wxString *arg2 = 0 ;
10769 int arg3 = (int) 0 ;
10770 wxString result;
10771 void *argp1 = 0 ;
10772 int res1 = 0 ;
10773 bool temp2 = false ;
10774 int val3 ;
10775 int ecode3 = 0 ;
10776 PyObject * obj0 = 0 ;
10777 PyObject * obj1 = 0 ;
10778 PyObject * obj2 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "spec",(char *) "flags", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10787 }
10788 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10789 {
10790 arg2 = wxString_in_helper(obj1);
10791 if (arg2 == NULL) SWIG_fail;
10792 temp2 = true;
10793 }
10794 if (obj2) {
10795 ecode3 = SWIG_AsVal_int(obj2, &val3);
10796 if (!SWIG_IsOK(ecode3)) {
10797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10798 }
10799 arg3 = static_cast< int >(val3);
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 {
10808 #if wxUSE_UNICODE
10809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10810 #else
10811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10812 #endif
10813 }
10814 {
10815 if (temp2)
10816 delete arg2;
10817 }
10818 return resultobj;
10819 fail:
10820 {
10821 if (temp2)
10822 delete arg2;
10823 }
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10829 PyObject *resultobj = 0;
10830 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10831 wxString result;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 PyObject *swig_obj[1] ;
10835
10836 if (!args) SWIG_fail;
10837 swig_obj[0] = args;
10838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10841 }
10842 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (arg1)->FindNext();
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 #if wxUSE_UNICODE
10851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10852 #else
10853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10854 #endif
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj = 0;
10864 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10865 int res1 = 0 ;
10866 PyObject * obj0 = 0 ;
10867 char * kwnames[] = {
10868 (char *) "handler", NULL
10869 };
10870
10871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10872 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10873 if (!SWIG_IsOK(res1)) {
10874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10875 }
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 wxFileSystem::AddHandler(arg1);
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891
10892 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 wxFileSystem::CleanUpHandlers();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxString *arg1 = 0 ;
10909 wxString result;
10910 bool temp1 = false ;
10911 PyObject * obj0 = 0 ;
10912 char * kwnames[] = {
10913 (char *) "filename", NULL
10914 };
10915
10916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10917 {
10918 arg1 = wxString_in_helper(obj0);
10919 if (arg1 == NULL) SWIG_fail;
10920 temp1 = true;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 #if wxUSE_UNICODE
10930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10931 #else
10932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10933 #endif
10934 }
10935 {
10936 if (temp1)
10937 delete arg1;
10938 }
10939 return resultobj;
10940 fail:
10941 {
10942 if (temp1)
10943 delete arg1;
10944 }
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxString *arg1 = 0 ;
10952 wxString result;
10953 bool temp1 = false ;
10954 PyObject * obj0 = 0 ;
10955 char * kwnames[] = {
10956 (char *) "url", NULL
10957 };
10958
10959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10960 {
10961 arg1 = wxString_in_helper(obj0);
10962 if (arg1 == NULL) SWIG_fail;
10963 temp1 = true;
10964 }
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 {
10972 #if wxUSE_UNICODE
10973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10974 #else
10975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10976 #endif
10977 }
10978 {
10979 if (temp1)
10980 delete arg1;
10981 }
10982 return resultobj;
10983 fail:
10984 {
10985 if (temp1)
10986 delete arg1;
10987 }
10988 return NULL;
10989 }
10990
10991
10992 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10993 PyObject *obj;
10994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10995 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10996 return SWIG_Py_Void();
10997 }
10998
10999 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 return SWIG_Python_InitShadowInstance(args);
11001 }
11002
11003 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *resultobj = 0;
11005 wxInternetFSHandler *result = 0 ;
11006
11007 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11015 return resultobj;
11016 fail:
11017 return NULL;
11018 }
11019
11020
11021 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11022 PyObject *resultobj = 0;
11023 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11024 wxString *arg2 = 0 ;
11025 bool result;
11026 void *argp1 = 0 ;
11027 int res1 = 0 ;
11028 bool temp2 = false ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "location", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11039 }
11040 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11041 {
11042 arg2 = wxString_in_helper(obj1);
11043 if (arg2 == NULL) SWIG_fail;
11044 temp2 = true;
11045 }
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11049 wxPyEndAllowThreads(__tstate);
11050 if (PyErr_Occurred()) SWIG_fail;
11051 }
11052 {
11053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11054 }
11055 {
11056 if (temp2)
11057 delete arg2;
11058 }
11059 return resultobj;
11060 fail:
11061 {
11062 if (temp2)
11063 delete arg2;
11064 }
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11070 PyObject *resultobj = 0;
11071 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11072 wxFileSystem *arg2 = 0 ;
11073 wxString *arg3 = 0 ;
11074 wxFSFile *result = 0 ;
11075 void *argp1 = 0 ;
11076 int res1 = 0 ;
11077 void *argp2 = 0 ;
11078 int res2 = 0 ;
11079 bool temp3 = false ;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char * kwnames[] = {
11084 (char *) "self",(char *) "fs",(char *) "location", NULL
11085 };
11086
11087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11089 if (!SWIG_IsOK(res1)) {
11090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11091 }
11092 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11094 if (!SWIG_IsOK(res2)) {
11095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11096 }
11097 if (!argp2) {
11098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11099 }
11100 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11101 {
11102 arg3 = wxString_in_helper(obj2);
11103 if (arg3 == NULL) SWIG_fail;
11104 temp3 = true;
11105 }
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11114 }
11115 {
11116 if (temp3)
11117 delete arg3;
11118 }
11119 return resultobj;
11120 fail:
11121 {
11122 if (temp3)
11123 delete arg3;
11124 }
11125 return NULL;
11126 }
11127
11128
11129 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11130 PyObject *obj;
11131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11132 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11133 return SWIG_Py_Void();
11134 }
11135
11136 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11137 return SWIG_Python_InitShadowInstance(args);
11138 }
11139
11140 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxZipFSHandler *result = 0 ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (wxZipFSHandler *)new wxZipFSHandler();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj = 0;
11160 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11161 wxString *arg2 = 0 ;
11162 bool result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 bool temp2 = false ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 char * kwnames[] = {
11169 (char *) "self",(char *) "location", NULL
11170 };
11171
11172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11174 if (!SWIG_IsOK(res1)) {
11175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11176 }
11177 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11178 {
11179 arg2 = wxString_in_helper(obj1);
11180 if (arg2 == NULL) SWIG_fail;
11181 temp2 = true;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11191 }
11192 {
11193 if (temp2)
11194 delete arg2;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp2)
11200 delete arg2;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11209 wxFileSystem *arg2 = 0 ;
11210 wxString *arg3 = 0 ;
11211 wxFSFile *result = 0 ;
11212 void *argp1 = 0 ;
11213 int res1 = 0 ;
11214 void *argp2 = 0 ;
11215 int res2 = 0 ;
11216 bool temp3 = false ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "self",(char *) "fs",(char *) "location", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11231 if (!SWIG_IsOK(res2)) {
11232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11233 }
11234 if (!argp2) {
11235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11236 }
11237 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11238 {
11239 arg3 = wxString_in_helper(obj2);
11240 if (arg3 == NULL) SWIG_fail;
11241 temp3 = true;
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11251 }
11252 {
11253 if (temp3)
11254 delete arg3;
11255 }
11256 return resultobj;
11257 fail:
11258 {
11259 if (temp3)
11260 delete arg3;
11261 }
11262 return NULL;
11263 }
11264
11265
11266 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11267 PyObject *resultobj = 0;
11268 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11269 wxString *arg2 = 0 ;
11270 int arg3 = (int) 0 ;
11271 wxString result;
11272 void *argp1 = 0 ;
11273 int res1 = 0 ;
11274 bool temp2 = false ;
11275 int val3 ;
11276 int ecode3 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "self",(char *) "spec",(char *) "flags", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11286 if (!SWIG_IsOK(res1)) {
11287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11288 }
11289 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11290 {
11291 arg2 = wxString_in_helper(obj1);
11292 if (arg2 == NULL) SWIG_fail;
11293 temp2 = true;
11294 }
11295 if (obj2) {
11296 ecode3 = SWIG_AsVal_int(obj2, &val3);
11297 if (!SWIG_IsOK(ecode3)) {
11298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11299 }
11300 arg3 = static_cast< int >(val3);
11301 }
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11305 wxPyEndAllowThreads(__tstate);
11306 if (PyErr_Occurred()) SWIG_fail;
11307 }
11308 {
11309 #if wxUSE_UNICODE
11310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11311 #else
11312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11313 #endif
11314 }
11315 {
11316 if (temp2)
11317 delete arg2;
11318 }
11319 return resultobj;
11320 fail:
11321 {
11322 if (temp2)
11323 delete arg2;
11324 }
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11330 PyObject *resultobj = 0;
11331 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11332 wxString result;
11333 void *argp1 = 0 ;
11334 int res1 = 0 ;
11335 PyObject *swig_obj[1] ;
11336
11337 if (!args) SWIG_fail;
11338 swig_obj[0] = args;
11339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11340 if (!SWIG_IsOK(res1)) {
11341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11342 }
11343 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (arg1)->FindNext();
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 #if wxUSE_UNICODE
11352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11353 #else
11354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11355 #endif
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11364 PyObject *obj;
11365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11366 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11367 return SWIG_Py_Void();
11368 }
11369
11370 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 return SWIG_Python_InitShadowInstance(args);
11372 }
11373
11374 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj = 0;
11376 wxString *arg1 = 0 ;
11377 wxImage *arg2 = 0 ;
11378 long arg3 ;
11379 bool temp1 = false ;
11380 void *argp2 = 0 ;
11381 int res2 = 0 ;
11382 long val3 ;
11383 int ecode3 = 0 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "filename",(char *) "image",(char *) "type", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11392 {
11393 arg1 = wxString_in_helper(obj0);
11394 if (arg1 == NULL) SWIG_fail;
11395 temp1 = true;
11396 }
11397 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11398 if (!SWIG_IsOK(res2)) {
11399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11400 }
11401 if (!argp2) {
11402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11403 }
11404 arg2 = reinterpret_cast< wxImage * >(argp2);
11405 ecode3 = SWIG_AsVal_long(obj2, &val3);
11406 if (!SWIG_IsOK(ecode3)) {
11407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11408 }
11409 arg3 = static_cast< long >(val3);
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 {
11418 if (temp1)
11419 delete arg1;
11420 }
11421 return resultobj;
11422 fail:
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxBitmap *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11460 }
11461 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 PyObject *arg2 = (PyObject *) 0 ;
11492 bool temp1 = false ;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "filename",(char *) "data", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11500 {
11501 arg1 = wxString_in_helper(obj0);
11502 if (arg1 == NULL) SWIG_fail;
11503 temp1 = true;
11504 }
11505 arg2 = obj1;
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 resultobj = SWIG_Py_Void();
11513 {
11514 if (temp1)
11515 delete arg1;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp1)
11521 delete arg1;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxMemoryFSHandler *result = 0 ;
11530
11531 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 bool temp1 = false ;
11549 PyObject * obj0 = 0 ;
11550 char * kwnames[] = {
11551 (char *) "filename", NULL
11552 };
11553
11554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11555 {
11556 arg1 = wxString_in_helper(obj0);
11557 if (arg1 == NULL) SWIG_fail;
11558 temp1 = true;
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_Py_Void();
11567 {
11568 if (temp1)
11569 delete arg1;
11570 }
11571 return resultobj;
11572 fail:
11573 {
11574 if (temp1)
11575 delete arg1;
11576 }
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11582 PyObject *resultobj = 0;
11583 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11584 wxString *arg2 = 0 ;
11585 bool result;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 bool temp2 = false ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 char * kwnames[] = {
11592 (char *) "self",(char *) "location", NULL
11593 };
11594
11595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11599 }
11600 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11601 {
11602 arg2 = wxString_in_helper(obj1);
11603 if (arg2 == NULL) SWIG_fail;
11604 temp2 = true;
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 return resultobj;
11620 fail:
11621 {
11622 if (temp2)
11623 delete arg2;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj = 0;
11631 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11632 wxFileSystem *arg2 = 0 ;
11633 wxString *arg3 = 0 ;
11634 wxFSFile *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 void *argp2 = 0 ;
11638 int res2 = 0 ;
11639 bool temp3 = false ;
11640 PyObject * obj0 = 0 ;
11641 PyObject * obj1 = 0 ;
11642 PyObject * obj2 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "fs",(char *) "location", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11654 if (!SWIG_IsOK(res2)) {
11655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11656 }
11657 if (!argp2) {
11658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11659 }
11660 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11661 {
11662 arg3 = wxString_in_helper(obj2);
11663 if (arg3 == NULL) SWIG_fail;
11664 temp3 = true;
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11674 }
11675 {
11676 if (temp3)
11677 delete arg3;
11678 }
11679 return resultobj;
11680 fail:
11681 {
11682 if (temp3)
11683 delete arg3;
11684 }
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11692 wxString *arg2 = 0 ;
11693 int arg3 = (int) 0 ;
11694 wxString result;
11695 void *argp1 = 0 ;
11696 int res1 = 0 ;
11697 bool temp2 = false ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "spec",(char *) "flags", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11711 }
11712 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11713 {
11714 arg2 = wxString_in_helper(obj1);
11715 if (arg2 == NULL) SWIG_fail;
11716 temp2 = true;
11717 }
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 #if wxUSE_UNICODE
11733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11734 #else
11735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11736 #endif
11737 }
11738 {
11739 if (temp2)
11740 delete arg2;
11741 }
11742 return resultobj;
11743 fail:
11744 {
11745 if (temp2)
11746 delete arg2;
11747 }
11748 return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753 PyObject *resultobj = 0;
11754 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11755 wxString result;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11765 }
11766 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (arg1)->FindNext();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 #if wxUSE_UNICODE
11775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11776 #else
11777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11778 #endif
11779 }
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *obj;
11788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11789 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11790 return SWIG_Py_Void();
11791 }
11792
11793 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 return SWIG_Python_InitShadowInstance(args);
11795 }
11796
11797 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 PyObject *resultobj = 0;
11799 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11800 wxString result;
11801 void *argp1 = 0 ;
11802 int res1 = 0 ;
11803 PyObject *swig_obj[1] ;
11804
11805 if (!args) SWIG_fail;
11806 swig_obj[0] = args;
11807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11808 if (!SWIG_IsOK(res1)) {
11809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11810 }
11811 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (arg1)->GetName();
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 #if wxUSE_UNICODE
11820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11821 #else
11822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11823 #endif
11824 }
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11832 PyObject *resultobj = 0;
11833 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11834 wxString result;
11835 void *argp1 = 0 ;
11836 int res1 = 0 ;
11837 PyObject *swig_obj[1] ;
11838
11839 if (!args) SWIG_fail;
11840 swig_obj[0] = args;
11841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11842 if (!SWIG_IsOK(res1)) {
11843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11844 }
11845 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (arg1)->GetExtension();
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 #if wxUSE_UNICODE
11854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11855 #else
11856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11857 #endif
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11868 long result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (long)(arg1)->GetType();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_From_long(static_cast< long >(result));
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11896 wxString result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11906 }
11907 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (arg1)->GetMimeType();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 #if wxUSE_UNICODE
11916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11917 #else
11918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11919 #endif
11920 }
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj = 0;
11929 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11930 wxString *arg2 = 0 ;
11931 bool result;
11932 void *argp1 = 0 ;
11933 int res1 = 0 ;
11934 bool temp2 = false ;
11935 PyObject * obj0 = 0 ;
11936 PyObject * obj1 = 0 ;
11937 char * kwnames[] = {
11938 (char *) "self",(char *) "name", NULL
11939 };
11940
11941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11943 if (!SWIG_IsOK(res1)) {
11944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11945 }
11946 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11947 {
11948 arg2 = wxString_in_helper(obj1);
11949 if (arg2 == NULL) SWIG_fail;
11950 temp2 = true;
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 {
11962 if (temp2)
11963 delete arg2;
11964 }
11965 return resultobj;
11966 fail:
11967 {
11968 if (temp2)
11969 delete arg2;
11970 }
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj = 0;
11977 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11978 wxInputStream *arg2 = 0 ;
11979 bool result;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 wxPyInputStream *temp2 ;
11983 bool created2 ;
11984 PyObject * obj0 = 0 ;
11985 PyObject * obj1 = 0 ;
11986 char * kwnames[] = {
11987 (char *) "self",(char *) "stream", NULL
11988 };
11989
11990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11994 }
11995 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11996 {
11997 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11998 arg2 = temp2->m_wxis;
11999 created2 = false;
12000 } else {
12001 PyErr_Clear(); // clear the failure of the wxPyConvert above
12002 arg2 = wxPyCBInputStream_create(obj1, false);
12003 if (arg2 == NULL) {
12004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12005 SWIG_fail;
12006 }
12007 created2 = true;
12008 }
12009 }
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (bool)(arg1)->CanRead(*arg2);
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12018 }
12019 {
12020 if (created2) delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (created2) delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj = 0;
12033 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12034 wxString *arg2 = 0 ;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 bool temp2 = false ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 char * kwnames[] = {
12041 (char *) "self",(char *) "name", NULL
12042 };
12043
12044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12046 if (!SWIG_IsOK(res1)) {
12047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12048 }
12049 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12050 {
12051 arg2 = wxString_in_helper(obj1);
12052 if (arg2 == NULL) SWIG_fail;
12053 temp2 = true;
12054 }
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 (arg1)->SetName((wxString const &)*arg2);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_Py_Void();
12062 {
12063 if (temp2)
12064 delete arg2;
12065 }
12066 return resultobj;
12067 fail:
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj = 0;
12078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12079 wxString *arg2 = 0 ;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 bool temp2 = false ;
12083 PyObject * obj0 = 0 ;
12084 PyObject * obj1 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "extension", NULL
12087 };
12088
12089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12091 if (!SWIG_IsOK(res1)) {
12092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12093 }
12094 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12095 {
12096 arg2 = wxString_in_helper(obj1);
12097 if (arg2 == NULL) SWIG_fail;
12098 temp2 = true;
12099 }
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 (arg1)->SetExtension((wxString const &)*arg2);
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 resultobj = SWIG_Py_Void();
12107 {
12108 if (temp2)
12109 delete arg2;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 return NULL;
12118 }
12119
12120
12121 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj = 0;
12123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12124 long arg2 ;
12125 void *argp1 = 0 ;
12126 int res1 = 0 ;
12127 long val2 ;
12128 int ecode2 = 0 ;
12129 PyObject * obj0 = 0 ;
12130 PyObject * obj1 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "self",(char *) "type", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12137 if (!SWIG_IsOK(res1)) {
12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12139 }
12140 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12141 ecode2 = SWIG_AsVal_long(obj1, &val2);
12142 if (!SWIG_IsOK(ecode2)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12144 }
12145 arg2 = static_cast< long >(val2);
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 (arg1)->SetType(arg2);
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 resultobj = SWIG_Py_Void();
12153 return resultobj;
12154 fail:
12155 return NULL;
12156 }
12157
12158
12159 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12160 PyObject *resultobj = 0;
12161 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12162 wxString *arg2 = 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 bool temp2 = false ;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char * kwnames[] = {
12169 (char *) "self",(char *) "mimetype", NULL
12170 };
12171
12172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12174 if (!SWIG_IsOK(res1)) {
12175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12176 }
12177 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12178 {
12179 arg2 = wxString_in_helper(obj1);
12180 if (arg2 == NULL) SWIG_fail;
12181 temp2 = true;
12182 }
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 (arg1)->SetMimeType((wxString const &)*arg2);
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 resultobj = SWIG_Py_Void();
12190 {
12191 if (temp2)
12192 delete arg2;
12193 }
12194 return resultobj;
12195 fail:
12196 {
12197 if (temp2)
12198 delete arg2;
12199 }
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12205 PyObject *obj;
12206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12207 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12208 return SWIG_Py_Void();
12209 }
12210
12211 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *resultobj = 0;
12213 wxPyImageHandler *result = 0 ;
12214
12215 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (wxPyImageHandler *)new wxPyImageHandler();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12232 PyObject *arg2 = (PyObject *) 0 ;
12233 void *argp1 = 0 ;
12234 int res1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 PyObject * obj1 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "self",(char *) "self", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12245 }
12246 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12247 arg2 = obj1;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 (arg1)->_SetSelf(arg2);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 resultobj = SWIG_Py_Void();
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 return SWIG_Python_InitShadowInstance(args);
12270 }
12271
12272 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12273 PyObject *resultobj = 0;
12274 wxImageHistogram *result = 0 ;
12275
12276 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (wxImageHistogram *)new wxImageHistogram();
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj = 0;
12292 byte arg1 ;
12293 byte arg2 ;
12294 byte arg3 ;
12295 unsigned long result;
12296 unsigned char val1 ;
12297 int ecode1 = 0 ;
12298 unsigned char val2 ;
12299 int ecode2 = 0 ;
12300 unsigned char val3 ;
12301 int ecode3 = 0 ;
12302 PyObject * obj0 = 0 ;
12303 PyObject * obj1 = 0 ;
12304 PyObject * obj2 = 0 ;
12305 char * kwnames[] = {
12306 (char *) "r",(char *) "g",(char *) "b", NULL
12307 };
12308
12309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12310 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12311 if (!SWIG_IsOK(ecode1)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12313 }
12314 arg1 = static_cast< byte >(val1);
12315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12316 if (!SWIG_IsOK(ecode2)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12318 }
12319 arg2 = static_cast< byte >(val2);
12320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12321 if (!SWIG_IsOK(ecode3)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12323 }
12324 arg3 = static_cast< byte >(val3);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj = 0;
12340 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12341 byte *arg2 = (byte *) 0 ;
12342 byte *arg3 = (byte *) 0 ;
12343 byte *arg4 = (byte *) 0 ;
12344 byte arg5 = (byte) 1 ;
12345 byte arg6 = (byte) 0 ;
12346 byte arg7 = (byte) 0 ;
12347 bool result;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 byte temp2 ;
12351 int res2 = SWIG_TMPOBJ ;
12352 byte temp3 ;
12353 int res3 = SWIG_TMPOBJ ;
12354 byte temp4 ;
12355 int res4 = SWIG_TMPOBJ ;
12356 unsigned char val5 ;
12357 int ecode5 = 0 ;
12358 unsigned char val6 ;
12359 int ecode6 = 0 ;
12360 unsigned char val7 ;
12361 int ecode7 = 0 ;
12362 PyObject * obj0 = 0 ;
12363 PyObject * obj1 = 0 ;
12364 PyObject * obj2 = 0 ;
12365 PyObject * obj3 = 0 ;
12366 char * kwnames[] = {
12367 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12368 };
12369
12370 arg2 = &temp2;
12371 arg3 = &temp3;
12372 arg4 = &temp4;
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 if (obj1) {
12380 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12381 if (!SWIG_IsOK(ecode5)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12383 }
12384 arg5 = static_cast< byte >(val5);
12385 }
12386 if (obj2) {
12387 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12388 if (!SWIG_IsOK(ecode6)) {
12389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12390 }
12391 arg6 = static_cast< byte >(val6);
12392 }
12393 if (obj3) {
12394 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12395 if (!SWIG_IsOK(ecode7)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12397 }
12398 arg7 = static_cast< byte >(val7);
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 {
12407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12408 }
12409 if (SWIG_IsTmpObj(res2)) {
12410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12411 } else {
12412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12414 }
12415 if (SWIG_IsTmpObj(res3)) {
12416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12417 } else {
12418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12420 }
12421 if (SWIG_IsTmpObj(res4)) {
12422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12423 } else {
12424 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12436 unsigned long arg2 ;
12437 unsigned long result;
12438 void *argp1 = 0 ;
12439 int res1 = 0 ;
12440 unsigned long val2 ;
12441 int ecode2 = 0 ;
12442 PyObject * obj0 = 0 ;
12443 PyObject * obj1 = 0 ;
12444 char * kwnames[] = {
12445 (char *) "self",(char *) "key", NULL
12446 };
12447
12448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12450 if (!SWIG_IsOK(res1)) {
12451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12452 }
12453 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12454 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12455 if (!SWIG_IsOK(ecode2)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12457 }
12458 arg2 = static_cast< unsigned long >(val2);
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12475 byte arg2 ;
12476 byte arg3 ;
12477 byte arg4 ;
12478 unsigned long result;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 unsigned char val2 ;
12482 int ecode2 = 0 ;
12483 unsigned char val3 ;
12484 int ecode3 = 0 ;
12485 unsigned char val4 ;
12486 int ecode4 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 PyObject * obj2 = 0 ;
12490 PyObject * obj3 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12499 }
12500 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12501 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12502 if (!SWIG_IsOK(ecode2)) {
12503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12504 }
12505 arg2 = static_cast< byte >(val2);
12506 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12507 if (!SWIG_IsOK(ecode3)) {
12508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12509 }
12510 arg3 = static_cast< byte >(val3);
12511 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12512 if (!SWIG_IsOK(ecode4)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12514 }
12515 arg4 = static_cast< byte >(val4);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 wxColour *arg2 = 0 ;
12533 unsigned long result;
12534 void *argp1 = 0 ;
12535 int res1 = 0 ;
12536 wxColour temp2 ;
12537 PyObject * obj0 = 0 ;
12538 PyObject * obj1 = 0 ;
12539 char * kwnames[] = {
12540 (char *) "self",(char *) "colour", NULL
12541 };
12542
12543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12545 if (!SWIG_IsOK(res1)) {
12546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12547 }
12548 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12549 {
12550 arg2 = &temp2;
12551 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12552 }
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12556 wxPyEndAllowThreads(__tstate);
12557 if (PyErr_Occurred()) SWIG_fail;
12558 }
12559 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *obj;
12568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12569 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12570 return SWIG_Py_Void();
12571 }
12572
12573 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 return SWIG_Python_InitShadowInstance(args);
12575 }
12576
12577 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj = 0;
12579 byte arg1 = (byte) 0 ;
12580 byte arg2 = (byte) 0 ;
12581 byte arg3 = (byte) 0 ;
12582 wxImage_RGBValue *result = 0 ;
12583 unsigned char val1 ;
12584 int ecode1 = 0 ;
12585 unsigned char val2 ;
12586 int ecode2 = 0 ;
12587 unsigned char val3 ;
12588 int ecode3 = 0 ;
12589 PyObject * obj0 = 0 ;
12590 PyObject * obj1 = 0 ;
12591 PyObject * obj2 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "r",(char *) "g",(char *) "b", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12597 if (obj0) {
12598 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12599 if (!SWIG_IsOK(ecode1)) {
12600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12601 }
12602 arg1 = static_cast< byte >(val1);
12603 }
12604 if (obj1) {
12605 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12606 if (!SWIG_IsOK(ecode2)) {
12607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12608 }
12609 arg2 = static_cast< byte >(val2);
12610 }
12611 if (obj2) {
12612 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12613 if (!SWIG_IsOK(ecode3)) {
12614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12615 }
12616 arg3 = static_cast< byte >(val3);
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12634 byte arg2 ;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 unsigned char val2 ;
12638 int ecode2 = 0 ;
12639 PyObject *swig_obj[2] ;
12640
12641 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12643 if (!SWIG_IsOK(res1)) {
12644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12645 }
12646 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 if (arg1) (arg1)->red = arg2;
12653
12654 resultobj = SWIG_Py_Void();
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12664 byte result;
12665 void *argp1 = 0 ;
12666 int res1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12672 if (!SWIG_IsOK(res1)) {
12673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12674 }
12675 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12676 result = (byte) ((arg1)->red);
12677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12687 byte arg2 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 unsigned char val2 ;
12691 int ecode2 = 0 ;
12692 PyObject *swig_obj[2] ;
12693
12694 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12698 }
12699 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12700 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12703 }
12704 arg2 = static_cast< byte >(val2);
12705 if (arg1) (arg1)->green = arg2;
12706
12707 resultobj = SWIG_Py_Void();
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12715 PyObject *resultobj = 0;
12716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12717 byte result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject *swig_obj[1] ;
12721
12722 if (!args) SWIG_fail;
12723 swig_obj[0] = args;
12724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12725 if (!SWIG_IsOK(res1)) {
12726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12727 }
12728 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12729 result = (byte) ((arg1)->green);
12730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12740 byte arg2 ;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 unsigned char val2 ;
12744 int ecode2 = 0 ;
12745 PyObject *swig_obj[2] ;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12751 }
12752 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12753 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12756 }
12757 arg2 = static_cast< byte >(val2);
12758 if (arg1) (arg1)->blue = arg2;
12759
12760 resultobj = SWIG_Py_Void();
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768 PyObject *resultobj = 0;
12769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12770 byte result;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 if (!args) SWIG_fail;
12776 swig_obj[0] = args;
12777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12778 if (!SWIG_IsOK(res1)) {
12779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12780 }
12781 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12782 result = (byte) ((arg1)->blue);
12783 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *obj;
12792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12793 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12794 return SWIG_Py_Void();
12795 }
12796
12797 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 return SWIG_Python_InitShadowInstance(args);
12799 }
12800
12801 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12802 PyObject *resultobj = 0;
12803 double arg1 = (double) 0.0 ;
12804 double arg2 = (double) 0.0 ;
12805 double arg3 = (double) 0.0 ;
12806 wxImage_HSVValue *result = 0 ;
12807 double val1 ;
12808 int ecode1 = 0 ;
12809 double val2 ;
12810 int ecode2 = 0 ;
12811 double val3 ;
12812 int ecode3 = 0 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12816 char * kwnames[] = {
12817 (char *) "h",(char *) "s",(char *) "v", NULL
12818 };
12819
12820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12821 if (obj0) {
12822 ecode1 = SWIG_AsVal_double(obj0, &val1);
12823 if (!SWIG_IsOK(ecode1)) {
12824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12825 }
12826 arg1 = static_cast< double >(val1);
12827 }
12828 if (obj1) {
12829 ecode2 = SWIG_AsVal_double(obj1, &val2);
12830 if (!SWIG_IsOK(ecode2)) {
12831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12832 }
12833 arg2 = static_cast< double >(val2);
12834 }
12835 if (obj2) {
12836 ecode3 = SWIG_AsVal_double(obj2, &val3);
12837 if (!SWIG_IsOK(ecode3)) {
12838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12839 }
12840 arg3 = static_cast< double >(val3);
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 PyObject *resultobj = 0;
12857 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12858 double arg2 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 double val2 ;
12862 int ecode2 = 0 ;
12863 PyObject *swig_obj[2] ;
12864
12865 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12867 if (!SWIG_IsOK(res1)) {
12868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12869 }
12870 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12871 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 if (arg1) (arg1)->hue = arg2;
12877
12878 resultobj = SWIG_Py_Void();
12879 return resultobj;
12880 fail:
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12886 PyObject *resultobj = 0;
12887 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12888 double result;
12889 void *argp1 = 0 ;
12890 int res1 = 0 ;
12891 PyObject *swig_obj[1] ;
12892
12893 if (!args) SWIG_fail;
12894 swig_obj[0] = args;
12895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12896 if (!SWIG_IsOK(res1)) {
12897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12898 }
12899 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12900 result = (double) ((arg1)->hue);
12901 resultobj = SWIG_From_double(static_cast< double >(result));
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12911 double arg2 ;
12912 void *argp1 = 0 ;
12913 int res1 = 0 ;
12914 double val2 ;
12915 int ecode2 = 0 ;
12916 PyObject *swig_obj[2] ;
12917
12918 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12922 }
12923 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12924 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12925 if (!SWIG_IsOK(ecode2)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12927 }
12928 arg2 = static_cast< double >(val2);
12929 if (arg1) (arg1)->saturation = arg2;
12930
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12941 double result;
12942 void *argp1 = 0 ;
12943 int res1 = 0 ;
12944 PyObject *swig_obj[1] ;
12945
12946 if (!args) SWIG_fail;
12947 swig_obj[0] = args;
12948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12951 }
12952 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12953 result = (double) ((arg1)->saturation);
12954 resultobj = SWIG_From_double(static_cast< double >(result));
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *resultobj = 0;
12963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12964 double arg2 ;
12965 void *argp1 = 0 ;
12966 int res1 = 0 ;
12967 double val2 ;
12968 int ecode2 = 0 ;
12969 PyObject *swig_obj[2] ;
12970
12971 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12973 if (!SWIG_IsOK(res1)) {
12974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12975 }
12976 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12977 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12978 if (!SWIG_IsOK(ecode2)) {
12979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12980 }
12981 arg2 = static_cast< double >(val2);
12982 if (arg1) (arg1)->value = arg2;
12983
12984 resultobj = SWIG_Py_Void();
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 PyObject *resultobj = 0;
12993 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12994 double result;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 PyObject *swig_obj[1] ;
12998
12999 if (!args) SWIG_fail;
13000 swig_obj[0] = args;
13001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13002 if (!SWIG_IsOK(res1)) {
13003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13004 }
13005 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13006 result = (double) ((arg1)->value);
13007 resultobj = SWIG_From_double(static_cast< double >(result));
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *obj;
13016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13017 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13018 return SWIG_Py_Void();
13019 }
13020
13021 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 return SWIG_Python_InitShadowInstance(args);
13023 }
13024
13025 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13026 PyObject *resultobj = 0;
13027 wxString *arg1 = 0 ;
13028 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13029 int arg3 = (int) -1 ;
13030 wxImage *result = 0 ;
13031 bool temp1 = false ;
13032 long val2 ;
13033 int ecode2 = 0 ;
13034 int val3 ;
13035 int ecode3 = 0 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 PyObject * obj2 = 0 ;
13039 char * kwnames[] = {
13040 (char *) "name",(char *) "type",(char *) "index", NULL
13041 };
13042
13043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13044 {
13045 arg1 = wxString_in_helper(obj0);
13046 if (arg1 == NULL) SWIG_fail;
13047 temp1 = true;
13048 }
13049 if (obj1) {
13050 ecode2 = SWIG_AsVal_long(obj1, &val2);
13051 if (!SWIG_IsOK(ecode2)) {
13052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13053 }
13054 arg2 = static_cast< long >(val2);
13055 }
13056 if (obj2) {
13057 ecode3 = SWIG_AsVal_int(obj2, &val3);
13058 if (!SWIG_IsOK(ecode3)) {
13059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13060 }
13061 arg3 = static_cast< int >(val3);
13062 }
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13070 {
13071 if (temp1)
13072 delete arg1;
13073 }
13074 return resultobj;
13075 fail:
13076 {
13077 if (temp1)
13078 delete arg1;
13079 }
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *resultobj = 0;
13086 wxImage *arg1 = (wxImage *) 0 ;
13087 void *argp1 = 0 ;
13088 int res1 = 0 ;
13089 PyObject *swig_obj[1] ;
13090
13091 if (!args) SWIG_fail;
13092 swig_obj[0] = args;
13093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13096 }
13097 arg1 = reinterpret_cast< wxImage * >(argp1);
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 delete arg1;
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_Py_Void();
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj = 0;
13114 wxString *arg1 = 0 ;
13115 wxString *arg2 = 0 ;
13116 int arg3 = (int) -1 ;
13117 wxImage *result = 0 ;
13118 bool temp1 = false ;
13119 bool temp2 = false ;
13120 int val3 ;
13121 int ecode3 = 0 ;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 PyObject * obj2 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13130 {
13131 arg1 = wxString_in_helper(obj0);
13132 if (arg1 == NULL) SWIG_fail;
13133 temp1 = true;
13134 }
13135 {
13136 arg2 = wxString_in_helper(obj1);
13137 if (arg2 == NULL) SWIG_fail;
13138 temp2 = true;
13139 }
13140 if (obj2) {
13141 ecode3 = SWIG_AsVal_int(obj2, &val3);
13142 if (!SWIG_IsOK(ecode3)) {
13143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13144 }
13145 arg3 = static_cast< int >(val3);
13146 }
13147 {
13148 PyThreadState* __tstate = wxPyBeginAllowThreads();
13149 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13150 wxPyEndAllowThreads(__tstate);
13151 if (PyErr_Occurred()) SWIG_fail;
13152 }
13153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13154 {
13155 if (temp1)
13156 delete arg1;
13157 }
13158 {
13159 if (temp2)
13160 delete arg2;
13161 }
13162 return resultobj;
13163 fail:
13164 {
13165 if (temp1)
13166 delete arg1;
13167 }
13168 {
13169 if (temp2)
13170 delete arg2;
13171 }
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxInputStream *arg1 = 0 ;
13179 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13180 int arg3 = (int) -1 ;
13181 wxImage *result = 0 ;
13182 wxPyInputStream *temp1 ;
13183 bool created1 ;
13184 long val2 ;
13185 int ecode2 = 0 ;
13186 int val3 ;
13187 int ecode3 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 PyObject * obj2 = 0 ;
13191 char * kwnames[] = {
13192 (char *) "stream",(char *) "type",(char *) "index", NULL
13193 };
13194
13195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13196 {
13197 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13198 arg1 = temp1->m_wxis;
13199 created1 = false;
13200 } else {
13201 PyErr_Clear(); // clear the failure of the wxPyConvert above
13202 arg1 = wxPyCBInputStream_create(obj0, false);
13203 if (arg1 == NULL) {
13204 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13205 SWIG_fail;
13206 }
13207 created1 = true;
13208 }
13209 }
13210 if (obj1) {
13211 ecode2 = SWIG_AsVal_long(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13214 }
13215 arg2 = static_cast< long >(val2);
13216 }
13217 if (obj2) {
13218 ecode3 = SWIG_AsVal_int(obj2, &val3);
13219 if (!SWIG_IsOK(ecode3)) {
13220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13221 }
13222 arg3 = static_cast< int >(val3);
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13231 {
13232 if (created1) delete arg1;
13233 }
13234 return resultobj;
13235 fail:
13236 {
13237 if (created1) delete arg1;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj = 0;
13245 wxInputStream *arg1 = 0 ;
13246 wxString *arg2 = 0 ;
13247 int arg3 = (int) -1 ;
13248 wxImage *result = 0 ;
13249 wxPyInputStream *temp1 ;
13250 bool created1 ;
13251 bool temp2 = false ;
13252 int val3 ;
13253 int ecode3 = 0 ;
13254 PyObject * obj0 = 0 ;
13255 PyObject * obj1 = 0 ;
13256 PyObject * obj2 = 0 ;
13257 char * kwnames[] = {
13258 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13259 };
13260
13261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13262 {
13263 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13264 arg1 = temp1->m_wxis;
13265 created1 = false;
13266 } else {
13267 PyErr_Clear(); // clear the failure of the wxPyConvert above
13268 arg1 = wxPyCBInputStream_create(obj0, false);
13269 if (arg1 == NULL) {
13270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13271 SWIG_fail;
13272 }
13273 created1 = true;
13274 }
13275 }
13276 {
13277 arg2 = wxString_in_helper(obj1);
13278 if (arg2 == NULL) SWIG_fail;
13279 temp2 = true;
13280 }
13281 if (obj2) {
13282 ecode3 = SWIG_AsVal_int(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13285 }
13286 arg3 = static_cast< int >(val3);
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13295 {
13296 if (created1) delete arg1;
13297 }
13298 {
13299 if (temp2)
13300 delete arg2;
13301 }
13302 return resultobj;
13303 fail:
13304 {
13305 if (created1) delete arg1;
13306 }
13307 {
13308 if (temp2)
13309 delete arg2;
13310 }
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13316 PyObject *resultobj = 0;
13317 int arg1 = (int) 0 ;
13318 int arg2 = (int) 0 ;
13319 bool arg3 = (bool) true ;
13320 wxImage *result = 0 ;
13321 int val1 ;
13322 int ecode1 = 0 ;
13323 int val2 ;
13324 int ecode2 = 0 ;
13325 bool val3 ;
13326 int ecode3 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "width",(char *) "height",(char *) "clear", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13335 if (obj0) {
13336 ecode1 = SWIG_AsVal_int(obj0, &val1);
13337 if (!SWIG_IsOK(ecode1)) {
13338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13339 }
13340 arg1 = static_cast< int >(val1);
13341 }
13342 if (obj1) {
13343 ecode2 = SWIG_AsVal_int(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13346 }
13347 arg2 = static_cast< int >(val2);
13348 }
13349 if (obj2) {
13350 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13353 }
13354 arg3 = static_cast< bool >(val3);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = 0;
13371 wxBitmap *arg1 = 0 ;
13372 wxImage *result = 0 ;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject * obj0 = 0 ;
13376 char * kwnames[] = {
13377 (char *) "bitmap", NULL
13378 };
13379
13380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13381 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13382 if (!SWIG_IsOK(res1)) {
13383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13384 }
13385 if (!argp1) {
13386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13387 }
13388 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13389 {
13390 if (!wxPyCheckForApp()) SWIG_fail;
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj = 0;
13405 int arg1 ;
13406 int arg2 ;
13407 buffer arg3 ;
13408 int arg4 ;
13409 wxImage *result = 0 ;
13410 int val1 ;
13411 int ecode1 = 0 ;
13412 int val2 ;
13413 int ecode2 = 0 ;
13414 Py_ssize_t temp3 ;
13415 PyObject * obj0 = 0 ;
13416 PyObject * obj1 = 0 ;
13417 PyObject * obj2 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "width",(char *) "height",(char *) "data", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13423 ecode1 = SWIG_AsVal_int(obj0, &val1);
13424 if (!SWIG_IsOK(ecode1)) {
13425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13426 }
13427 arg1 = static_cast< int >(val1);
13428 ecode2 = SWIG_AsVal_int(obj1, &val2);
13429 if (!SWIG_IsOK(ecode2)) {
13430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13431 }
13432 arg2 = static_cast< int >(val2);
13433 {
13434 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13435 arg4 = (int)temp3;
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = 0;
13452 int arg1 ;
13453 int arg2 ;
13454 buffer arg3 ;
13455 int arg4 ;
13456 buffer arg5 ;
13457 int arg6 ;
13458 wxImage *result = 0 ;
13459 int val1 ;
13460 int ecode1 = 0 ;
13461 int val2 ;
13462 int ecode2 = 0 ;
13463 Py_ssize_t temp3 ;
13464 Py_ssize_t temp5 ;
13465 PyObject * obj0 = 0 ;
13466 PyObject * obj1 = 0 ;
13467 PyObject * obj2 = 0 ;
13468 PyObject * obj3 = 0 ;
13469 char * kwnames[] = {
13470 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13471 };
13472
13473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13474 ecode1 = SWIG_AsVal_int(obj0, &val1);
13475 if (!SWIG_IsOK(ecode1)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13477 }
13478 arg1 = static_cast< int >(val1);
13479 ecode2 = SWIG_AsVal_int(obj1, &val2);
13480 if (!SWIG_IsOK(ecode2)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13482 }
13483 arg2 = static_cast< int >(val2);
13484 {
13485 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13486 arg4 = (int)temp3;
13487 }
13488 {
13489 if (obj3 != Py_None) {
13490 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13491 arg6 = (int)temp5;
13492 }
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13501 return resultobj;
13502 fail:
13503 return NULL;
13504 }
13505
13506
13507 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13508 PyObject *resultobj = 0;
13509 wxImage *arg1 = (wxImage *) 0 ;
13510 int arg2 ;
13511 int arg3 ;
13512 bool arg4 = (bool) true ;
13513 void *argp1 = 0 ;
13514 int res1 = 0 ;
13515 int val2 ;
13516 int ecode2 = 0 ;
13517 int val3 ;
13518 int ecode3 = 0 ;
13519 bool val4 ;
13520 int ecode4 = 0 ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 PyObject * obj3 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 if (obj3) {
13546 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13547 if (!SWIG_IsOK(ecode4)) {
13548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13549 }
13550 arg4 = static_cast< bool >(val4);
13551 }
13552 {
13553 PyThreadState* __tstate = wxPyBeginAllowThreads();
13554 (arg1)->Create(arg2,arg3,arg4);
13555 wxPyEndAllowThreads(__tstate);
13556 if (PyErr_Occurred()) SWIG_fail;
13557 }
13558 resultobj = SWIG_Py_Void();
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13566 PyObject *resultobj = 0;
13567 wxImage *arg1 = (wxImage *) 0 ;
13568 void *argp1 = 0 ;
13569 int res1 = 0 ;
13570 PyObject *swig_obj[1] ;
13571
13572 if (!args) SWIG_fail;
13573 swig_obj[0] = args;
13574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13575 if (!SWIG_IsOK(res1)) {
13576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13577 }
13578 arg1 = reinterpret_cast< wxImage * >(argp1);
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 (arg1)->Destroy();
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_Py_Void();
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13593 PyObject *resultobj = 0;
13594 wxImage *arg1 = (wxImage *) 0 ;
13595 int arg2 ;
13596 int arg3 ;
13597 SwigValueWrapper<wxImage > result;
13598 void *argp1 = 0 ;
13599 int res1 = 0 ;
13600 int val2 ;
13601 int ecode2 = 0 ;
13602 int val3 ;
13603 int ecode3 = 0 ;
13604 PyObject * obj0 = 0 ;
13605 PyObject * obj1 = 0 ;
13606 PyObject * obj2 = 0 ;
13607 char * kwnames[] = {
13608 (char *) "self",(char *) "width",(char *) "height", NULL
13609 };
13610
13611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13613 if (!SWIG_IsOK(res1)) {
13614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13615 }
13616 arg1 = reinterpret_cast< wxImage * >(argp1);
13617 ecode2 = SWIG_AsVal_int(obj1, &val2);
13618 if (!SWIG_IsOK(ecode2)) {
13619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13620 }
13621 arg2 = static_cast< int >(val2);
13622 ecode3 = SWIG_AsVal_int(obj2, &val3);
13623 if (!SWIG_IsOK(ecode3)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13625 }
13626 arg3 = static_cast< int >(val3);
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 result = (arg1)->Scale(arg2,arg3);
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj = 0;
13642 wxImage *arg1 = (wxImage *) 0 ;
13643 int arg2 ;
13644 int arg3 ;
13645 SwigValueWrapper<wxImage > result;
13646 void *argp1 = 0 ;
13647 int res1 = 0 ;
13648 int val2 ;
13649 int ecode2 = 0 ;
13650 int val3 ;
13651 int ecode3 = 0 ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 PyObject * obj2 = 0 ;
13655 char * kwnames[] = {
13656 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13657 };
13658
13659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13661 if (!SWIG_IsOK(res1)) {
13662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13663 }
13664 arg1 = reinterpret_cast< wxImage * >(argp1);
13665 ecode2 = SWIG_AsVal_int(obj1, &val2);
13666 if (!SWIG_IsOK(ecode2)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13668 }
13669 arg2 = static_cast< int >(val2);
13670 ecode3 = SWIG_AsVal_int(obj2, &val3);
13671 if (!SWIG_IsOK(ecode3)) {
13672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13673 }
13674 arg3 = static_cast< int >(val3);
13675 {
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13682 return resultobj;
13683 fail:
13684 return NULL;
13685 }
13686
13687
13688 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj = 0;
13690 wxImage *arg1 = (wxImage *) 0 ;
13691 int arg2 ;
13692 int arg3 ;
13693 wxImage *result = 0 ;
13694 void *argp1 = 0 ;
13695 int res1 = 0 ;
13696 int val2 ;
13697 int ecode2 = 0 ;
13698 int val3 ;
13699 int ecode3 = 0 ;
13700 PyObject * obj0 = 0 ;
13701 PyObject * obj1 = 0 ;
13702 PyObject * obj2 = 0 ;
13703 char * kwnames[] = {
13704 (char *) "self",(char *) "width",(char *) "height", NULL
13705 };
13706
13707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13709 if (!SWIG_IsOK(res1)) {
13710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13711 }
13712 arg1 = reinterpret_cast< wxImage * >(argp1);
13713 ecode2 = SWIG_AsVal_int(obj1, &val2);
13714 if (!SWIG_IsOK(ecode2)) {
13715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13716 }
13717 arg2 = static_cast< int >(val2);
13718 ecode3 = SWIG_AsVal_int(obj2, &val3);
13719 if (!SWIG_IsOK(ecode3)) {
13720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13721 }
13722 arg3 = static_cast< int >(val3);
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 {
13726 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13727 result = (wxImage *) &_result_ref;
13728 }
13729 wxPyEndAllowThreads(__tstate);
13730 if (PyErr_Occurred()) SWIG_fail;
13731 }
13732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13733 return resultobj;
13734 fail:
13735 return NULL;
13736 }
13737
13738
13739 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13740 PyObject *resultobj = 0;
13741 wxImage *arg1 = (wxImage *) 0 ;
13742 wxSize *arg2 = 0 ;
13743 wxPoint *arg3 = 0 ;
13744 int arg4 = (int) -1 ;
13745 int arg5 = (int) -1 ;
13746 int arg6 = (int) -1 ;
13747 wxImage *result = 0 ;
13748 void *argp1 = 0 ;
13749 int res1 = 0 ;
13750 wxSize temp2 ;
13751 wxPoint temp3 ;
13752 int val4 ;
13753 int ecode4 = 0 ;
13754 int val5 ;
13755 int ecode5 = 0 ;
13756 int val6 ;
13757 int ecode6 = 0 ;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 PyObject * obj3 = 0 ;
13762 PyObject * obj4 = 0 ;
13763 PyObject * obj5 = 0 ;
13764 char * kwnames[] = {
13765 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13766 };
13767
13768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13770 if (!SWIG_IsOK(res1)) {
13771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13772 }
13773 arg1 = reinterpret_cast< wxImage * >(argp1);
13774 {
13775 arg2 = &temp2;
13776 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13777 }
13778 {
13779 arg3 = &temp3;
13780 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13781 }
13782 if (obj3) {
13783 ecode4 = SWIG_AsVal_int(obj3, &val4);
13784 if (!SWIG_IsOK(ecode4)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13786 }
13787 arg4 = static_cast< int >(val4);
13788 }
13789 if (obj4) {
13790 ecode5 = SWIG_AsVal_int(obj4, &val5);
13791 if (!SWIG_IsOK(ecode5)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13793 }
13794 arg5 = static_cast< int >(val5);
13795 }
13796 if (obj5) {
13797 ecode6 = SWIG_AsVal_int(obj5, &val6);
13798 if (!SWIG_IsOK(ecode6)) {
13799 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13800 }
13801 arg6 = static_cast< int >(val6);
13802 }
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 {
13806 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13807 result = (wxImage *) &_result_ref;
13808 }
13809 wxPyEndAllowThreads(__tstate);
13810 if (PyErr_Occurred()) SWIG_fail;
13811 }
13812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13813 return resultobj;
13814 fail:
13815 return NULL;
13816 }
13817
13818
13819 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13820 PyObject *resultobj = 0;
13821 wxImage *arg1 = (wxImage *) 0 ;
13822 int arg2 ;
13823 int arg3 ;
13824 byte arg4 ;
13825 byte arg5 ;
13826 byte arg6 ;
13827 void *argp1 = 0 ;
13828 int res1 = 0 ;
13829 int val2 ;
13830 int ecode2 = 0 ;
13831 int val3 ;
13832 int ecode3 = 0 ;
13833 unsigned char val4 ;
13834 int ecode4 = 0 ;
13835 unsigned char val5 ;
13836 int ecode5 = 0 ;
13837 unsigned char val6 ;
13838 int ecode6 = 0 ;
13839 PyObject * obj0 = 0 ;
13840 PyObject * obj1 = 0 ;
13841 PyObject * obj2 = 0 ;
13842 PyObject * obj3 = 0 ;
13843 PyObject * obj4 = 0 ;
13844 PyObject * obj5 = 0 ;
13845 char * kwnames[] = {
13846 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13847 };
13848
13849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13851 if (!SWIG_IsOK(res1)) {
13852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13853 }
13854 arg1 = reinterpret_cast< wxImage * >(argp1);
13855 ecode2 = SWIG_AsVal_int(obj1, &val2);
13856 if (!SWIG_IsOK(ecode2)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13858 }
13859 arg2 = static_cast< int >(val2);
13860 ecode3 = SWIG_AsVal_int(obj2, &val3);
13861 if (!SWIG_IsOK(ecode3)) {
13862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13863 }
13864 arg3 = static_cast< int >(val3);
13865 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13866 if (!SWIG_IsOK(ecode4)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13868 }
13869 arg4 = static_cast< byte >(val4);
13870 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13871 if (!SWIG_IsOK(ecode5)) {
13872 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13873 }
13874 arg5 = static_cast< byte >(val5);
13875 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13876 if (!SWIG_IsOK(ecode6)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13878 }
13879 arg6 = static_cast< byte >(val6);
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_Py_Void();
13887 return resultobj;
13888 fail:
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxImage *arg1 = (wxImage *) 0 ;
13896 wxRect *arg2 = 0 ;
13897 byte arg3 ;
13898 byte arg4 ;
13899 byte arg5 ;
13900 void *argp1 = 0 ;
13901 int res1 = 0 ;
13902 wxRect temp2 ;
13903 unsigned char val3 ;
13904 int ecode3 = 0 ;
13905 unsigned char val4 ;
13906 int ecode4 = 0 ;
13907 unsigned char val5 ;
13908 int ecode5 = 0 ;
13909 PyObject * obj0 = 0 ;
13910 PyObject * obj1 = 0 ;
13911 PyObject * obj2 = 0 ;
13912 PyObject * obj3 = 0 ;
13913 PyObject * obj4 = 0 ;
13914 char * kwnames[] = {
13915 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13916 };
13917
13918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13920 if (!SWIG_IsOK(res1)) {
13921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13922 }
13923 arg1 = reinterpret_cast< wxImage * >(argp1);
13924 {
13925 arg2 = &temp2;
13926 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13927 }
13928 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13929 if (!SWIG_IsOK(ecode3)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13931 }
13932 arg3 = static_cast< byte >(val3);
13933 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13934 if (!SWIG_IsOK(ecode4)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13936 }
13937 arg4 = static_cast< byte >(val4);
13938 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13939 if (!SWIG_IsOK(ecode5)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13941 }
13942 arg5 = static_cast< byte >(val5);
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 resultobj = SWIG_Py_Void();
13950 return resultobj;
13951 fail:
13952 return NULL;
13953 }
13954
13955
13956 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13957 PyObject *resultobj = 0;
13958 wxImage *arg1 = (wxImage *) 0 ;
13959 int arg2 ;
13960 int arg3 ;
13961 byte result;
13962 void *argp1 = 0 ;
13963 int res1 = 0 ;
13964 int val2 ;
13965 int ecode2 = 0 ;
13966 int val3 ;
13967 int ecode3 = 0 ;
13968 PyObject * obj0 = 0 ;
13969 PyObject * obj1 = 0 ;
13970 PyObject * obj2 = 0 ;
13971 char * kwnames[] = {
13972 (char *) "self",(char *) "x",(char *) "y", NULL
13973 };
13974
13975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13977 if (!SWIG_IsOK(res1)) {
13978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13979 }
13980 arg1 = reinterpret_cast< wxImage * >(argp1);
13981 ecode2 = SWIG_AsVal_int(obj1, &val2);
13982 if (!SWIG_IsOK(ecode2)) {
13983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13984 }
13985 arg2 = static_cast< int >(val2);
13986 ecode3 = SWIG_AsVal_int(obj2, &val3);
13987 if (!SWIG_IsOK(ecode3)) {
13988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13989 }
13990 arg3 = static_cast< int >(val3);
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = (byte)(arg1)->GetRed(arg2,arg3);
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = 0;
14006 wxImage *arg1 = (wxImage *) 0 ;
14007 int arg2 ;
14008 int arg3 ;
14009 byte result;
14010 void *argp1 = 0 ;
14011 int res1 = 0 ;
14012 int val2 ;
14013 int ecode2 = 0 ;
14014 int val3 ;
14015 int ecode3 = 0 ;
14016 PyObject * obj0 = 0 ;
14017 PyObject * obj1 = 0 ;
14018 PyObject * obj2 = 0 ;
14019 char * kwnames[] = {
14020 (char *) "self",(char *) "x",(char *) "y", NULL
14021 };
14022
14023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14025 if (!SWIG_IsOK(res1)) {
14026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14027 }
14028 arg1 = reinterpret_cast< wxImage * >(argp1);
14029 ecode2 = SWIG_AsVal_int(obj1, &val2);
14030 if (!SWIG_IsOK(ecode2)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14032 }
14033 arg2 = static_cast< int >(val2);
14034 ecode3 = SWIG_AsVal_int(obj2, &val3);
14035 if (!SWIG_IsOK(ecode3)) {
14036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14037 }
14038 arg3 = static_cast< int >(val3);
14039 {
14040 PyThreadState* __tstate = wxPyBeginAllowThreads();
14041 result = (byte)(arg1)->GetGreen(arg2,arg3);
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14046 return resultobj;
14047 fail:
14048 return NULL;
14049 }
14050
14051
14052 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14053 PyObject *resultobj = 0;
14054 wxImage *arg1 = (wxImage *) 0 ;
14055 int arg2 ;
14056 int arg3 ;
14057 byte result;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 int val2 ;
14061 int ecode2 = 0 ;
14062 int val3 ;
14063 int ecode3 = 0 ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 PyObject * obj2 = 0 ;
14067 char * kwnames[] = {
14068 (char *) "self",(char *) "x",(char *) "y", NULL
14069 };
14070
14071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14073 if (!SWIG_IsOK(res1)) {
14074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14075 }
14076 arg1 = reinterpret_cast< wxImage * >(argp1);
14077 ecode2 = SWIG_AsVal_int(obj1, &val2);
14078 if (!SWIG_IsOK(ecode2)) {
14079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14080 }
14081 arg2 = static_cast< int >(val2);
14082 ecode3 = SWIG_AsVal_int(obj2, &val3);
14083 if (!SWIG_IsOK(ecode3)) {
14084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14085 }
14086 arg3 = static_cast< int >(val3);
14087 {
14088 PyThreadState* __tstate = wxPyBeginAllowThreads();
14089 result = (byte)(arg1)->GetBlue(arg2,arg3);
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14094 return resultobj;
14095 fail:
14096 return NULL;
14097 }
14098
14099
14100 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14101 PyObject *resultobj = 0;
14102 wxImage *arg1 = (wxImage *) 0 ;
14103 int arg2 ;
14104 int arg3 ;
14105 byte arg4 ;
14106 void *argp1 = 0 ;
14107 int res1 = 0 ;
14108 int val2 ;
14109 int ecode2 = 0 ;
14110 int val3 ;
14111 int ecode3 = 0 ;
14112 unsigned char val4 ;
14113 int ecode4 = 0 ;
14114 PyObject * obj0 = 0 ;
14115 PyObject * obj1 = 0 ;
14116 PyObject * obj2 = 0 ;
14117 PyObject * obj3 = 0 ;
14118 char * kwnames[] = {
14119 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14120 };
14121
14122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14124 if (!SWIG_IsOK(res1)) {
14125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14126 }
14127 arg1 = reinterpret_cast< wxImage * >(argp1);
14128 ecode2 = SWIG_AsVal_int(obj1, &val2);
14129 if (!SWIG_IsOK(ecode2)) {
14130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14131 }
14132 arg2 = static_cast< int >(val2);
14133 ecode3 = SWIG_AsVal_int(obj2, &val3);
14134 if (!SWIG_IsOK(ecode3)) {
14135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14136 }
14137 arg3 = static_cast< int >(val3);
14138 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14139 if (!SWIG_IsOK(ecode4)) {
14140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14141 }
14142 arg4 = static_cast< byte >(val4);
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 (arg1)->SetAlpha(arg2,arg3,arg4);
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 resultobj = SWIG_Py_Void();
14150 return resultobj;
14151 fail:
14152 return NULL;
14153 }
14154
14155
14156 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj = 0;
14158 wxImage *arg1 = (wxImage *) 0 ;
14159 int arg2 ;
14160 int arg3 ;
14161 byte result;
14162 void *argp1 = 0 ;
14163 int res1 = 0 ;
14164 int val2 ;
14165 int ecode2 = 0 ;
14166 int val3 ;
14167 int ecode3 = 0 ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 PyObject * obj2 = 0 ;
14171 char * kwnames[] = {
14172 (char *) "self",(char *) "x",(char *) "y", NULL
14173 };
14174
14175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 ecode2 = SWIG_AsVal_int(obj1, &val2);
14182 if (!SWIG_IsOK(ecode2)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14184 }
14185 arg2 = static_cast< int >(val2);
14186 ecode3 = SWIG_AsVal_int(obj2, &val3);
14187 if (!SWIG_IsOK(ecode3)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14189 }
14190 arg3 = static_cast< int >(val3);
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14205 PyObject *resultobj = 0;
14206 wxImage *arg1 = (wxImage *) 0 ;
14207 bool result;
14208 void *argp1 = 0 ;
14209 int res1 = 0 ;
14210 PyObject *swig_obj[1] ;
14211
14212 if (!args) SWIG_fail;
14213 swig_obj[0] = args;
14214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14215 if (!SWIG_IsOK(res1)) {
14216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14217 }
14218 arg1 = reinterpret_cast< wxImage * >(argp1);
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 result = (bool)(arg1)->HasAlpha();
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 {
14226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14227 }
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14235 PyObject *resultobj = 0;
14236 wxImage *arg1 = (wxImage *) 0 ;
14237 void *argp1 = 0 ;
14238 int res1 = 0 ;
14239 PyObject *swig_obj[1] ;
14240
14241 if (!args) SWIG_fail;
14242 swig_obj[0] = args;
14243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14246 }
14247 arg1 = reinterpret_cast< wxImage * >(argp1);
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 (arg1)->InitAlpha();
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 resultobj = SWIG_Py_Void();
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14262 PyObject *resultobj = 0;
14263 wxImage *arg1 = (wxImage *) 0 ;
14264 int arg2 ;
14265 int arg3 ;
14266 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14267 bool result;
14268 void *argp1 = 0 ;
14269 int res1 = 0 ;
14270 int val2 ;
14271 int ecode2 = 0 ;
14272 int val3 ;
14273 int ecode3 = 0 ;
14274 unsigned char val4 ;
14275 int ecode4 = 0 ;
14276 PyObject * obj0 = 0 ;
14277 PyObject * obj1 = 0 ;
14278 PyObject * obj2 = 0 ;
14279 PyObject * obj3 = 0 ;
14280 char * kwnames[] = {
14281 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14282 };
14283
14284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14286 if (!SWIG_IsOK(res1)) {
14287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14288 }
14289 arg1 = reinterpret_cast< wxImage * >(argp1);
14290 ecode2 = SWIG_AsVal_int(obj1, &val2);
14291 if (!SWIG_IsOK(ecode2)) {
14292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14293 }
14294 arg2 = static_cast< int >(val2);
14295 ecode3 = SWIG_AsVal_int(obj2, &val3);
14296 if (!SWIG_IsOK(ecode3)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14298 }
14299 arg3 = static_cast< int >(val3);
14300 if (obj3) {
14301 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14302 if (!SWIG_IsOK(ecode4)) {
14303 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14304 }
14305 arg4 = static_cast< byte >(val4);
14306 }
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 {
14314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14315 }
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj = 0;
14324 wxImage *arg1 = (wxImage *) 0 ;
14325 byte *arg2 = (byte *) 0 ;
14326 byte *arg3 = (byte *) 0 ;
14327 byte *arg4 = (byte *) 0 ;
14328 byte arg5 = (byte) 0 ;
14329 byte arg6 = (byte) 0 ;
14330 byte arg7 = (byte) 0 ;
14331 bool result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 byte temp2 ;
14335 int res2 = SWIG_TMPOBJ ;
14336 byte temp3 ;
14337 int res3 = SWIG_TMPOBJ ;
14338 byte temp4 ;
14339 int res4 = SWIG_TMPOBJ ;
14340 unsigned char val5 ;
14341 int ecode5 = 0 ;
14342 unsigned char val6 ;
14343 int ecode6 = 0 ;
14344 unsigned char val7 ;
14345 int ecode7 = 0 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 PyObject * obj2 = 0 ;
14349 PyObject * obj3 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14352 };
14353
14354 arg2 = &temp2;
14355 arg3 = &temp3;
14356 arg4 = &temp4;
14357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14359 if (!SWIG_IsOK(res1)) {
14360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14361 }
14362 arg1 = reinterpret_cast< wxImage * >(argp1);
14363 if (obj1) {
14364 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14365 if (!SWIG_IsOK(ecode5)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14367 }
14368 arg5 = static_cast< byte >(val5);
14369 }
14370 if (obj2) {
14371 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14372 if (!SWIG_IsOK(ecode6)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14374 }
14375 arg6 = static_cast< byte >(val6);
14376 }
14377 if (obj3) {
14378 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14379 if (!SWIG_IsOK(ecode7)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14381 }
14382 arg7 = static_cast< byte >(val7);
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 {
14391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14392 }
14393 if (SWIG_IsTmpObj(res2)) {
14394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14395 } else {
14396 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14398 }
14399 if (SWIG_IsTmpObj(res3)) {
14400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14401 } else {
14402 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14404 }
14405 if (SWIG_IsTmpObj(res4)) {
14406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14407 } else {
14408 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14410 }
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj = 0;
14419 wxImage *arg1 = (wxImage *) 0 ;
14420 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14421 bool result;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 unsigned char val2 ;
14425 int ecode2 = 0 ;
14426 PyObject * obj0 = 0 ;
14427 PyObject * obj1 = 0 ;
14428 char * kwnames[] = {
14429 (char *) "self",(char *) "threshold", NULL
14430 };
14431
14432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14434 if (!SWIG_IsOK(res1)) {
14435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14436 }
14437 arg1 = reinterpret_cast< wxImage * >(argp1);
14438 if (obj1) {
14439 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14440 if (!SWIG_IsOK(ecode2)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14442 }
14443 arg2 = static_cast< byte >(val2);
14444 }
14445 {
14446 PyThreadState* __tstate = wxPyBeginAllowThreads();
14447 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14448 wxPyEndAllowThreads(__tstate);
14449 if (PyErr_Occurred()) SWIG_fail;
14450 }
14451 {
14452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14453 }
14454 return resultobj;
14455 fail:
14456 return NULL;
14457 }
14458
14459
14460 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14461 PyObject *resultobj = 0;
14462 wxImage *arg1 = (wxImage *) 0 ;
14463 byte arg2 ;
14464 byte arg3 ;
14465 byte arg4 ;
14466 bool result;
14467 void *argp1 = 0 ;
14468 int res1 = 0 ;
14469 unsigned char val2 ;
14470 int ecode2 = 0 ;
14471 unsigned char val3 ;
14472 int ecode3 = 0 ;
14473 unsigned char val4 ;
14474 int ecode4 = 0 ;
14475 PyObject * obj0 = 0 ;
14476 PyObject * obj1 = 0 ;
14477 PyObject * obj2 = 0 ;
14478 PyObject * obj3 = 0 ;
14479 char * kwnames[] = {
14480 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14481 };
14482
14483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14485 if (!SWIG_IsOK(res1)) {
14486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14487 }
14488 arg1 = reinterpret_cast< wxImage * >(argp1);
14489 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14490 if (!SWIG_IsOK(ecode2)) {
14491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14492 }
14493 arg2 = static_cast< byte >(val2);
14494 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14495 if (!SWIG_IsOK(ecode3)) {
14496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14497 }
14498 arg3 = static_cast< byte >(val3);
14499 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14500 if (!SWIG_IsOK(ecode4)) {
14501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14502 }
14503 arg4 = static_cast< byte >(val4);
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 {
14511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14512 }
14513 return resultobj;
14514 fail:
14515 return NULL;
14516 }
14517
14518
14519 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14520 PyObject *resultobj = 0;
14521 wxImage *arg1 = (wxImage *) 0 ;
14522 wxImage *arg2 = 0 ;
14523 byte arg3 ;
14524 byte arg4 ;
14525 byte arg5 ;
14526 bool result;
14527 void *argp1 = 0 ;
14528 int res1 = 0 ;
14529 void *argp2 = 0 ;
14530 int res2 = 0 ;
14531 unsigned char val3 ;
14532 int ecode3 = 0 ;
14533 unsigned char val4 ;
14534 int ecode4 = 0 ;
14535 unsigned char val5 ;
14536 int ecode5 = 0 ;
14537 PyObject * obj0 = 0 ;
14538 PyObject * obj1 = 0 ;
14539 PyObject * obj2 = 0 ;
14540 PyObject * obj3 = 0 ;
14541 PyObject * obj4 = 0 ;
14542 char * kwnames[] = {
14543 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14544 };
14545
14546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14548 if (!SWIG_IsOK(res1)) {
14549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14550 }
14551 arg1 = reinterpret_cast< wxImage * >(argp1);
14552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14553 if (!SWIG_IsOK(res2)) {
14554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14555 }
14556 if (!argp2) {
14557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14558 }
14559 arg2 = reinterpret_cast< wxImage * >(argp2);
14560 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14561 if (!SWIG_IsOK(ecode3)) {
14562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14563 }
14564 arg3 = static_cast< byte >(val3);
14565 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14566 if (!SWIG_IsOK(ecode4)) {
14567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14568 }
14569 arg4 = static_cast< byte >(val4);
14570 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14571 if (!SWIG_IsOK(ecode5)) {
14572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14573 }
14574 arg5 = static_cast< byte >(val5);
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14578 wxPyEndAllowThreads(__tstate);
14579 if (PyErr_Occurred()) SWIG_fail;
14580 }
14581 {
14582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14583 }
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj = 0;
14592 wxString *arg1 = 0 ;
14593 bool result;
14594 bool temp1 = false ;
14595 PyObject * obj0 = 0 ;
14596 char * kwnames[] = {
14597 (char *) "filename", NULL
14598 };
14599
14600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14601 {
14602 arg1 = wxString_in_helper(obj0);
14603 if (arg1 == NULL) SWIG_fail;
14604 temp1 = true;
14605 }
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14614 }
14615 {
14616 if (temp1)
14617 delete arg1;
14618 }
14619 return resultobj;
14620 fail:
14621 {
14622 if (temp1)
14623 delete arg1;
14624 }
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14630 PyObject *resultobj = 0;
14631 wxString *arg1 = 0 ;
14632 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14633 int result;
14634 bool temp1 = false ;
14635 long val2 ;
14636 int ecode2 = 0 ;
14637 PyObject * obj0 = 0 ;
14638 PyObject * obj1 = 0 ;
14639 char * kwnames[] = {
14640 (char *) "filename",(char *) "type", NULL
14641 };
14642
14643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14644 {
14645 arg1 = wxString_in_helper(obj0);
14646 if (arg1 == NULL) SWIG_fail;
14647 temp1 = true;
14648 }
14649 if (obj1) {
14650 ecode2 = SWIG_AsVal_long(obj1, &val2);
14651 if (!SWIG_IsOK(ecode2)) {
14652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14653 }
14654 arg2 = static_cast< long >(val2);
14655 }
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 resultobj = SWIG_From_int(static_cast< int >(result));
14663 {
14664 if (temp1)
14665 delete arg1;
14666 }
14667 return resultobj;
14668 fail:
14669 {
14670 if (temp1)
14671 delete arg1;
14672 }
14673 return NULL;
14674 }
14675
14676
14677 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14678 PyObject *resultobj = 0;
14679 wxImage *arg1 = (wxImage *) 0 ;
14680 wxString *arg2 = 0 ;
14681 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14682 int arg4 = (int) -1 ;
14683 bool result;
14684 void *argp1 = 0 ;
14685 int res1 = 0 ;
14686 bool temp2 = false ;
14687 long val3 ;
14688 int ecode3 = 0 ;
14689 int val4 ;
14690 int ecode4 = 0 ;
14691 PyObject * obj0 = 0 ;
14692 PyObject * obj1 = 0 ;
14693 PyObject * obj2 = 0 ;
14694 PyObject * obj3 = 0 ;
14695 char * kwnames[] = {
14696 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14697 };
14698
14699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14701 if (!SWIG_IsOK(res1)) {
14702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14703 }
14704 arg1 = reinterpret_cast< wxImage * >(argp1);
14705 {
14706 arg2 = wxString_in_helper(obj1);
14707 if (arg2 == NULL) SWIG_fail;
14708 temp2 = true;
14709 }
14710 if (obj2) {
14711 ecode3 = SWIG_AsVal_long(obj2, &val3);
14712 if (!SWIG_IsOK(ecode3)) {
14713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14714 }
14715 arg3 = static_cast< long >(val3);
14716 }
14717 if (obj3) {
14718 ecode4 = SWIG_AsVal_int(obj3, &val4);
14719 if (!SWIG_IsOK(ecode4)) {
14720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14721 }
14722 arg4 = static_cast< int >(val4);
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 {
14731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14732 }
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 return resultobj;
14738 fail:
14739 {
14740 if (temp2)
14741 delete arg2;
14742 }
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj = 0;
14749 wxImage *arg1 = (wxImage *) 0 ;
14750 wxString *arg2 = 0 ;
14751 wxString *arg3 = 0 ;
14752 int arg4 = (int) -1 ;
14753 bool result;
14754 void *argp1 = 0 ;
14755 int res1 = 0 ;
14756 bool temp2 = false ;
14757 bool temp3 = false ;
14758 int val4 ;
14759 int ecode4 = 0 ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 PyObject * obj2 = 0 ;
14763 PyObject * obj3 = 0 ;
14764 char * kwnames[] = {
14765 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14766 };
14767
14768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14770 if (!SWIG_IsOK(res1)) {
14771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14772 }
14773 arg1 = reinterpret_cast< wxImage * >(argp1);
14774 {
14775 arg2 = wxString_in_helper(obj1);
14776 if (arg2 == NULL) SWIG_fail;
14777 temp2 = true;
14778 }
14779 {
14780 arg3 = wxString_in_helper(obj2);
14781 if (arg3 == NULL) SWIG_fail;
14782 temp3 = true;
14783 }
14784 if (obj3) {
14785 ecode4 = SWIG_AsVal_int(obj3, &val4);
14786 if (!SWIG_IsOK(ecode4)) {
14787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14788 }
14789 arg4 = static_cast< int >(val4);
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 {
14798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14799 }
14800 {
14801 if (temp2)
14802 delete arg2;
14803 }
14804 {
14805 if (temp3)
14806 delete arg3;
14807 }
14808 return resultobj;
14809 fail:
14810 {
14811 if (temp2)
14812 delete arg2;
14813 }
14814 {
14815 if (temp3)
14816 delete arg3;
14817 }
14818 return NULL;
14819 }
14820
14821
14822 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj = 0;
14824 wxImage *arg1 = (wxImage *) 0 ;
14825 wxString *arg2 = 0 ;
14826 int arg3 ;
14827 bool result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 bool temp2 = false ;
14831 int val3 ;
14832 int ecode3 = 0 ;
14833 PyObject * obj0 = 0 ;
14834 PyObject * obj1 = 0 ;
14835 PyObject * obj2 = 0 ;
14836 char * kwnames[] = {
14837 (char *) "self",(char *) "name",(char *) "type", NULL
14838 };
14839
14840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14842 if (!SWIG_IsOK(res1)) {
14843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14844 }
14845 arg1 = reinterpret_cast< wxImage * >(argp1);
14846 {
14847 arg2 = wxString_in_helper(obj1);
14848 if (arg2 == NULL) SWIG_fail;
14849 temp2 = true;
14850 }
14851 ecode3 = SWIG_AsVal_int(obj2, &val3);
14852 if (!SWIG_IsOK(ecode3)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14854 }
14855 arg3 = static_cast< int >(val3);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 {
14863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14864 }
14865 {
14866 if (temp2)
14867 delete arg2;
14868 }
14869 return resultobj;
14870 fail:
14871 {
14872 if (temp2)
14873 delete arg2;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 wxString *arg2 = 0 ;
14883 wxString *arg3 = 0 ;
14884 bool result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 bool temp2 = false ;
14888 bool temp3 = false ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14894 };
14895
14896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14898 if (!SWIG_IsOK(res1)) {
14899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14900 }
14901 arg1 = reinterpret_cast< wxImage * >(argp1);
14902 {
14903 arg2 = wxString_in_helper(obj1);
14904 if (arg2 == NULL) SWIG_fail;
14905 temp2 = true;
14906 }
14907 {
14908 arg3 = wxString_in_helper(obj2);
14909 if (arg3 == NULL) SWIG_fail;
14910 temp3 = true;
14911 }
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 {
14919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14920 }
14921 {
14922 if (temp2)
14923 delete arg2;
14924 }
14925 {
14926 if (temp3)
14927 delete arg3;
14928 }
14929 return resultobj;
14930 fail:
14931 {
14932 if (temp2)
14933 delete arg2;
14934 }
14935 {
14936 if (temp3)
14937 delete arg3;
14938 }
14939 return NULL;
14940 }
14941
14942
14943 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14944 PyObject *resultobj = 0;
14945 wxInputStream *arg1 = 0 ;
14946 bool result;
14947 wxPyInputStream *temp1 ;
14948 bool created1 ;
14949 PyObject * obj0 = 0 ;
14950 char * kwnames[] = {
14951 (char *) "stream", NULL
14952 };
14953
14954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14955 {
14956 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14957 arg1 = temp1->m_wxis;
14958 created1 = false;
14959 } else {
14960 PyErr_Clear(); // clear the failure of the wxPyConvert above
14961 arg1 = wxPyCBInputStream_create(obj0, false);
14962 if (arg1 == NULL) {
14963 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14964 SWIG_fail;
14965 }
14966 created1 = true;
14967 }
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 result = (bool)wxImage::CanRead(*arg1);
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14977 }
14978 {
14979 if (created1) delete arg1;
14980 }
14981 return resultobj;
14982 fail:
14983 {
14984 if (created1) delete arg1;
14985 }
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj = 0;
14992 wxImage *arg1 = (wxImage *) 0 ;
14993 wxInputStream *arg2 = 0 ;
14994 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14995 int arg4 = (int) -1 ;
14996 bool result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 wxPyInputStream *temp2 ;
15000 bool created2 ;
15001 long val3 ;
15002 int ecode3 = 0 ;
15003 int val4 ;
15004 int ecode4 = 0 ;
15005 PyObject * obj0 = 0 ;
15006 PyObject * obj1 = 0 ;
15007 PyObject * obj2 = 0 ;
15008 PyObject * obj3 = 0 ;
15009 char * kwnames[] = {
15010 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15011 };
15012
15013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15015 if (!SWIG_IsOK(res1)) {
15016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15017 }
15018 arg1 = reinterpret_cast< wxImage * >(argp1);
15019 {
15020 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15021 arg2 = temp2->m_wxis;
15022 created2 = false;
15023 } else {
15024 PyErr_Clear(); // clear the failure of the wxPyConvert above
15025 arg2 = wxPyCBInputStream_create(obj1, false);
15026 if (arg2 == NULL) {
15027 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15028 SWIG_fail;
15029 }
15030 created2 = true;
15031 }
15032 }
15033 if (obj2) {
15034 ecode3 = SWIG_AsVal_long(obj2, &val3);
15035 if (!SWIG_IsOK(ecode3)) {
15036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15037 }
15038 arg3 = static_cast< long >(val3);
15039 }
15040 if (obj3) {
15041 ecode4 = SWIG_AsVal_int(obj3, &val4);
15042 if (!SWIG_IsOK(ecode4)) {
15043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15044 }
15045 arg4 = static_cast< int >(val4);
15046 }
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 {
15054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15055 }
15056 {
15057 if (created2) delete arg2;
15058 }
15059 return resultobj;
15060 fail:
15061 {
15062 if (created2) delete arg2;
15063 }
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj = 0;
15070 wxImage *arg1 = (wxImage *) 0 ;
15071 wxInputStream *arg2 = 0 ;
15072 wxString *arg3 = 0 ;
15073 int arg4 = (int) -1 ;
15074 bool result;
15075 void *argp1 = 0 ;
15076 int res1 = 0 ;
15077 wxPyInputStream *temp2 ;
15078 bool created2 ;
15079 bool temp3 = false ;
15080 int val4 ;
15081 int ecode4 = 0 ;
15082 PyObject * obj0 = 0 ;
15083 PyObject * obj1 = 0 ;
15084 PyObject * obj2 = 0 ;
15085 PyObject * obj3 = 0 ;
15086 char * kwnames[] = {
15087 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15088 };
15089
15090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15092 if (!SWIG_IsOK(res1)) {
15093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15094 }
15095 arg1 = reinterpret_cast< wxImage * >(argp1);
15096 {
15097 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15098 arg2 = temp2->m_wxis;
15099 created2 = false;
15100 } else {
15101 PyErr_Clear(); // clear the failure of the wxPyConvert above
15102 arg2 = wxPyCBInputStream_create(obj1, false);
15103 if (arg2 == NULL) {
15104 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15105 SWIG_fail;
15106 }
15107 created2 = true;
15108 }
15109 }
15110 {
15111 arg3 = wxString_in_helper(obj2);
15112 if (arg3 == NULL) SWIG_fail;
15113 temp3 = true;
15114 }
15115 if (obj3) {
15116 ecode4 = SWIG_AsVal_int(obj3, &val4);
15117 if (!SWIG_IsOK(ecode4)) {
15118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15119 }
15120 arg4 = static_cast< int >(val4);
15121 }
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 {
15129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15130 }
15131 {
15132 if (created2) delete arg2;
15133 }
15134 {
15135 if (temp3)
15136 delete arg3;
15137 }
15138 return resultobj;
15139 fail:
15140 {
15141 if (created2) delete arg2;
15142 }
15143 {
15144 if (temp3)
15145 delete arg3;
15146 }
15147 return NULL;
15148 }
15149
15150
15151 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15152 PyObject *resultobj = 0;
15153 wxImage *arg1 = (wxImage *) 0 ;
15154 bool result;
15155 void *argp1 = 0 ;
15156 int res1 = 0 ;
15157 PyObject *swig_obj[1] ;
15158
15159 if (!args) SWIG_fail;
15160 swig_obj[0] = args;
15161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15162 if (!SWIG_IsOK(res1)) {
15163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15164 }
15165 arg1 = reinterpret_cast< wxImage * >(argp1);
15166 {
15167 PyThreadState* __tstate = wxPyBeginAllowThreads();
15168 result = (bool)(arg1)->Ok();
15169 wxPyEndAllowThreads(__tstate);
15170 if (PyErr_Occurred()) SWIG_fail;
15171 }
15172 {
15173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15174 }
15175 return resultobj;
15176 fail:
15177 return NULL;
15178 }
15179
15180
15181 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15182 PyObject *resultobj = 0;
15183 wxImage *arg1 = (wxImage *) 0 ;
15184 int result;
15185 void *argp1 = 0 ;
15186 int res1 = 0 ;
15187 PyObject *swig_obj[1] ;
15188
15189 if (!args) SWIG_fail;
15190 swig_obj[0] = args;
15191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15192 if (!SWIG_IsOK(res1)) {
15193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15194 }
15195 arg1 = reinterpret_cast< wxImage * >(argp1);
15196 {
15197 PyThreadState* __tstate = wxPyBeginAllowThreads();
15198 result = (int)(arg1)->GetWidth();
15199 wxPyEndAllowThreads(__tstate);
15200 if (PyErr_Occurred()) SWIG_fail;
15201 }
15202 resultobj = SWIG_From_int(static_cast< int >(result));
15203 return resultobj;
15204 fail:
15205 return NULL;
15206 }
15207
15208
15209 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15210 PyObject *resultobj = 0;
15211 wxImage *arg1 = (wxImage *) 0 ;
15212 int result;
15213 void *argp1 = 0 ;
15214 int res1 = 0 ;
15215 PyObject *swig_obj[1] ;
15216
15217 if (!args) SWIG_fail;
15218 swig_obj[0] = args;
15219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15220 if (!SWIG_IsOK(res1)) {
15221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15222 }
15223 arg1 = reinterpret_cast< wxImage * >(argp1);
15224 {
15225 PyThreadState* __tstate = wxPyBeginAllowThreads();
15226 result = (int)(arg1)->GetHeight();
15227 wxPyEndAllowThreads(__tstate);
15228 if (PyErr_Occurred()) SWIG_fail;
15229 }
15230 resultobj = SWIG_From_int(static_cast< int >(result));
15231 return resultobj;
15232 fail:
15233 return NULL;
15234 }
15235
15236
15237 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15238 PyObject *resultobj = 0;
15239 wxImage *arg1 = (wxImage *) 0 ;
15240 wxSize result;
15241 void *argp1 = 0 ;
15242 int res1 = 0 ;
15243 PyObject *swig_obj[1] ;
15244
15245 if (!args) SWIG_fail;
15246 swig_obj[0] = args;
15247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15248 if (!SWIG_IsOK(res1)) {
15249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15250 }
15251 arg1 = reinterpret_cast< wxImage * >(argp1);
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = wxImage_GetSize(arg1);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15266 PyObject *resultobj = 0;
15267 wxImage *arg1 = (wxImage *) 0 ;
15268 wxRect *arg2 = 0 ;
15269 SwigValueWrapper<wxImage > result;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 wxRect temp2 ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 char * kwnames[] = {
15276 (char *) "self",(char *) "rect", NULL
15277 };
15278
15279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15283 }
15284 arg1 = reinterpret_cast< wxImage * >(argp1);
15285 {
15286 arg2 = &temp2;
15287 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15288 }
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj = 0;
15304 wxImage *arg1 = (wxImage *) 0 ;
15305 wxSize *arg2 = 0 ;
15306 wxPoint *arg3 = 0 ;
15307 int arg4 = (int) -1 ;
15308 int arg5 = (int) -1 ;
15309 int arg6 = (int) -1 ;
15310 SwigValueWrapper<wxImage > result;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 wxSize temp2 ;
15314 wxPoint temp3 ;
15315 int val4 ;
15316 int ecode4 = 0 ;
15317 int val5 ;
15318 int ecode5 = 0 ;
15319 int val6 ;
15320 int ecode6 = 0 ;
15321 PyObject * obj0 = 0 ;
15322 PyObject * obj1 = 0 ;
15323 PyObject * obj2 = 0 ;
15324 PyObject * obj3 = 0 ;
15325 PyObject * obj4 = 0 ;
15326 PyObject * obj5 = 0 ;
15327 char * kwnames[] = {
15328 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15329 };
15330
15331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15333 if (!SWIG_IsOK(res1)) {
15334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15335 }
15336 arg1 = reinterpret_cast< wxImage * >(argp1);
15337 {
15338 arg2 = &temp2;
15339 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15340 }
15341 {
15342 arg3 = &temp3;
15343 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15344 }
15345 if (obj3) {
15346 ecode4 = SWIG_AsVal_int(obj3, &val4);
15347 if (!SWIG_IsOK(ecode4)) {
15348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15349 }
15350 arg4 = static_cast< int >(val4);
15351 }
15352 if (obj4) {
15353 ecode5 = SWIG_AsVal_int(obj4, &val5);
15354 if (!SWIG_IsOK(ecode5)) {
15355 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15356 }
15357 arg5 = static_cast< int >(val5);
15358 }
15359 if (obj5) {
15360 ecode6 = SWIG_AsVal_int(obj5, &val6);
15361 if (!SWIG_IsOK(ecode6)) {
15362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15363 }
15364 arg6 = static_cast< int >(val6);
15365 }
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15380 PyObject *resultobj = 0;
15381 wxImage *arg1 = (wxImage *) 0 ;
15382 SwigValueWrapper<wxImage > result;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 PyObject *swig_obj[1] ;
15386
15387 if (!args) SWIG_fail;
15388 swig_obj[0] = args;
15389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 PyThreadState* __tstate = wxPyBeginAllowThreads();
15396 result = (arg1)->Copy();
15397 wxPyEndAllowThreads(__tstate);
15398 if (PyErr_Occurred()) SWIG_fail;
15399 }
15400 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxImage *arg1 = (wxImage *) 0 ;
15410 wxImage *arg2 = 0 ;
15411 int arg3 ;
15412 int arg4 ;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 void *argp2 = 0 ;
15416 int res2 = 0 ;
15417 int val3 ;
15418 int ecode3 = 0 ;
15419 int val4 ;
15420 int ecode4 = 0 ;
15421 PyObject * obj0 = 0 ;
15422 PyObject * obj1 = 0 ;
15423 PyObject * obj2 = 0 ;
15424 PyObject * obj3 = 0 ;
15425 char * kwnames[] = {
15426 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15427 };
15428
15429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15433 }
15434 arg1 = reinterpret_cast< wxImage * >(argp1);
15435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15436 if (!SWIG_IsOK(res2)) {
15437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15438 }
15439 if (!argp2) {
15440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15441 }
15442 arg2 = reinterpret_cast< wxImage * >(argp2);
15443 ecode3 = SWIG_AsVal_int(obj2, &val3);
15444 if (!SWIG_IsOK(ecode3)) {
15445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15446 }
15447 arg3 = static_cast< int >(val3);
15448 ecode4 = SWIG_AsVal_int(obj3, &val4);
15449 if (!SWIG_IsOK(ecode4)) {
15450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15451 }
15452 arg4 = static_cast< int >(val4);
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15456 wxPyEndAllowThreads(__tstate);
15457 if (PyErr_Occurred()) SWIG_fail;
15458 }
15459 resultobj = SWIG_Py_Void();
15460 return resultobj;
15461 fail:
15462 return NULL;
15463 }
15464
15465
15466 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15467 PyObject *resultobj = 0;
15468 wxImage *arg1 = (wxImage *) 0 ;
15469 PyObject *result = 0 ;
15470 void *argp1 = 0 ;
15471 int res1 = 0 ;
15472 PyObject *swig_obj[1] ;
15473
15474 if (!args) SWIG_fail;
15475 swig_obj[0] = args;
15476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15477 if (!SWIG_IsOK(res1)) {
15478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15479 }
15480 arg1 = reinterpret_cast< wxImage * >(argp1);
15481 {
15482 PyThreadState* __tstate = wxPyBeginAllowThreads();
15483 result = (PyObject *)wxImage_GetData(arg1);
15484 wxPyEndAllowThreads(__tstate);
15485 if (PyErr_Occurred()) SWIG_fail;
15486 }
15487 resultobj = result;
15488 return resultobj;
15489 fail:
15490 return NULL;
15491 }
15492
15493
15494 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15495 PyObject *resultobj = 0;
15496 wxImage *arg1 = (wxImage *) 0 ;
15497 buffer arg2 ;
15498 int arg3 ;
15499 void *argp1 = 0 ;
15500 int res1 = 0 ;
15501 Py_ssize_t temp2 ;
15502 PyObject * obj0 = 0 ;
15503 PyObject * obj1 = 0 ;
15504 char * kwnames[] = {
15505 (char *) "self",(char *) "data", NULL
15506 };
15507
15508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15510 if (!SWIG_IsOK(res1)) {
15511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15512 }
15513 arg1 = reinterpret_cast< wxImage * >(argp1);
15514 {
15515 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15516 arg3 = (int)temp2;
15517 }
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 wxImage_SetData(arg1,arg2,arg3);
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 resultobj = SWIG_Py_Void();
15525 return resultobj;
15526 fail:
15527 return NULL;
15528 }
15529
15530
15531 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15532 PyObject *resultobj = 0;
15533 wxImage *arg1 = (wxImage *) 0 ;
15534 PyObject *result = 0 ;
15535 void *argp1 = 0 ;
15536 int res1 = 0 ;
15537 PyObject *swig_obj[1] ;
15538
15539 if (!args) SWIG_fail;
15540 swig_obj[0] = args;
15541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15542 if (!SWIG_IsOK(res1)) {
15543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15544 }
15545 arg1 = reinterpret_cast< wxImage * >(argp1);
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 resultobj = result;
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj = 0;
15561 wxImage *arg1 = (wxImage *) 0 ;
15562 buffer arg2 ;
15563 int arg3 ;
15564 void *argp1 = 0 ;
15565 int res1 = 0 ;
15566 Py_ssize_t temp2 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 char * kwnames[] = {
15570 (char *) "self",(char *) "data", NULL
15571 };
15572
15573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15577 }
15578 arg1 = reinterpret_cast< wxImage * >(argp1);
15579 {
15580 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15581 arg3 = (int)temp2;
15582 }
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 wxImage_SetDataBuffer(arg1,arg2,arg3);
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_Py_Void();
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 PyObject *result = 0 ;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 PyObject *swig_obj[1] ;
15603
15604 if (!args) SWIG_fail;
15605 swig_obj[0] = args;
15606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15609 }
15610 arg1 = reinterpret_cast< wxImage * >(argp1);
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (PyObject *)wxImage_GetAlphaData(arg1);
15614 wxPyEndAllowThreads(__tstate);
15615 if (PyErr_Occurred()) SWIG_fail;
15616 }
15617 resultobj = result;
15618 return resultobj;
15619 fail:
15620 return NULL;
15621 }
15622
15623
15624 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15625 PyObject *resultobj = 0;
15626 wxImage *arg1 = (wxImage *) 0 ;
15627 buffer arg2 ;
15628 int arg3 ;
15629 void *argp1 = 0 ;
15630 int res1 = 0 ;
15631 Py_ssize_t temp2 ;
15632 PyObject * obj0 = 0 ;
15633 PyObject * obj1 = 0 ;
15634 char * kwnames[] = {
15635 (char *) "self",(char *) "alpha", NULL
15636 };
15637
15638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15640 if (!SWIG_IsOK(res1)) {
15641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15642 }
15643 arg1 = reinterpret_cast< wxImage * >(argp1);
15644 {
15645 if (obj1 != Py_None) {
15646 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15647 arg3 = (int)temp2;
15648 }
15649 }
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 wxImage_SetAlphaData(arg1,arg2,arg3);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = SWIG_Py_Void();
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15664 PyObject *resultobj = 0;
15665 wxImage *arg1 = (wxImage *) 0 ;
15666 PyObject *result = 0 ;
15667 void *argp1 = 0 ;
15668 int res1 = 0 ;
15669 PyObject *swig_obj[1] ;
15670
15671 if (!args) SWIG_fail;
15672 swig_obj[0] = args;
15673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15674 if (!SWIG_IsOK(res1)) {
15675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15676 }
15677 arg1 = reinterpret_cast< wxImage * >(argp1);
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = result;
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15692 PyObject *resultobj = 0;
15693 wxImage *arg1 = (wxImage *) 0 ;
15694 buffer arg2 ;
15695 int arg3 ;
15696 void *argp1 = 0 ;
15697 int res1 = 0 ;
15698 Py_ssize_t temp2 ;
15699 PyObject * obj0 = 0 ;
15700 PyObject * obj1 = 0 ;
15701 char * kwnames[] = {
15702 (char *) "self",(char *) "alpha", NULL
15703 };
15704
15705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15707 if (!SWIG_IsOK(res1)) {
15708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15709 }
15710 arg1 = reinterpret_cast< wxImage * >(argp1);
15711 {
15712 if (obj1 != Py_None) {
15713 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15714 arg3 = (int)temp2;
15715 }
15716 }
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 resultobj = SWIG_Py_Void();
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15731 PyObject *resultobj = 0;
15732 wxImage *arg1 = (wxImage *) 0 ;
15733 byte arg2 ;
15734 byte arg3 ;
15735 byte arg4 ;
15736 void *argp1 = 0 ;
15737 int res1 = 0 ;
15738 unsigned char val2 ;
15739 int ecode2 = 0 ;
15740 unsigned char val3 ;
15741 int ecode3 = 0 ;
15742 unsigned char val4 ;
15743 int ecode4 = 0 ;
15744 PyObject * obj0 = 0 ;
15745 PyObject * obj1 = 0 ;
15746 PyObject * obj2 = 0 ;
15747 PyObject * obj3 = 0 ;
15748 char * kwnames[] = {
15749 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15750 };
15751
15752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15754 if (!SWIG_IsOK(res1)) {
15755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15756 }
15757 arg1 = reinterpret_cast< wxImage * >(argp1);
15758 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15759 if (!SWIG_IsOK(ecode2)) {
15760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15761 }
15762 arg2 = static_cast< byte >(val2);
15763 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15764 if (!SWIG_IsOK(ecode3)) {
15765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15766 }
15767 arg3 = static_cast< byte >(val3);
15768 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15769 if (!SWIG_IsOK(ecode4)) {
15770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15771 }
15772 arg4 = static_cast< byte >(val4);
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 (arg1)->SetMaskColour(arg2,arg3,arg4);
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 resultobj = SWIG_Py_Void();
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15787 PyObject *resultobj = 0;
15788 wxImage *arg1 = (wxImage *) 0 ;
15789 byte *arg2 = (byte *) 0 ;
15790 byte *arg3 = (byte *) 0 ;
15791 byte *arg4 = (byte *) 0 ;
15792 void *argp1 = 0 ;
15793 int res1 = 0 ;
15794 byte temp2 ;
15795 int res2 = SWIG_TMPOBJ ;
15796 byte temp3 ;
15797 int res3 = SWIG_TMPOBJ ;
15798 byte temp4 ;
15799 int res4 = SWIG_TMPOBJ ;
15800 PyObject *swig_obj[1] ;
15801
15802 arg2 = &temp2;
15803 arg3 = &temp3;
15804 arg4 = &temp4;
15805 if (!args) SWIG_fail;
15806 swig_obj[0] = args;
15807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15808 if (!SWIG_IsOK(res1)) {
15809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15810 }
15811 arg1 = reinterpret_cast< wxImage * >(argp1);
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 resultobj = SWIG_Py_Void();
15819 if (SWIG_IsTmpObj(res2)) {
15820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15821 } else {
15822 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15824 }
15825 if (SWIG_IsTmpObj(res3)) {
15826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15827 } else {
15828 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15830 }
15831 if (SWIG_IsTmpObj(res4)) {
15832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15833 } else {
15834 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15836 }
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *resultobj = 0;
15845 wxImage *arg1 = (wxImage *) 0 ;
15846 byte result;
15847 void *argp1 = 0 ;
15848 int res1 = 0 ;
15849 PyObject *swig_obj[1] ;
15850
15851 if (!args) SWIG_fail;
15852 swig_obj[0] = args;
15853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15854 if (!SWIG_IsOK(res1)) {
15855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15856 }
15857 arg1 = reinterpret_cast< wxImage * >(argp1);
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = (byte)(arg1)->GetMaskRed();
15861 wxPyEndAllowThreads(__tstate);
15862 if (PyErr_Occurred()) SWIG_fail;
15863 }
15864 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15872 PyObject *resultobj = 0;
15873 wxImage *arg1 = (wxImage *) 0 ;
15874 byte result;
15875 void *argp1 = 0 ;
15876 int res1 = 0 ;
15877 PyObject *swig_obj[1] ;
15878
15879 if (!args) SWIG_fail;
15880 swig_obj[0] = args;
15881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15884 }
15885 arg1 = reinterpret_cast< wxImage * >(argp1);
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (byte)(arg1)->GetMaskGreen();
15889 wxPyEndAllowThreads(__tstate);
15890 if (PyErr_Occurred()) SWIG_fail;
15891 }
15892 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15900 PyObject *resultobj = 0;
15901 wxImage *arg1 = (wxImage *) 0 ;
15902 byte result;
15903 void *argp1 = 0 ;
15904 int res1 = 0 ;
15905 PyObject *swig_obj[1] ;
15906
15907 if (!args) SWIG_fail;
15908 swig_obj[0] = args;
15909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15910 if (!SWIG_IsOK(res1)) {
15911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15912 }
15913 arg1 = reinterpret_cast< wxImage * >(argp1);
15914 {
15915 PyThreadState* __tstate = wxPyBeginAllowThreads();
15916 result = (byte)(arg1)->GetMaskBlue();
15917 wxPyEndAllowThreads(__tstate);
15918 if (PyErr_Occurred()) SWIG_fail;
15919 }
15920 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15921 return resultobj;
15922 fail:
15923 return NULL;
15924 }
15925
15926
15927 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15928 PyObject *resultobj = 0;
15929 wxImage *arg1 = (wxImage *) 0 ;
15930 bool arg2 = (bool) true ;
15931 void *argp1 = 0 ;
15932 int res1 = 0 ;
15933 bool val2 ;
15934 int ecode2 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 char * kwnames[] = {
15938 (char *) "self",(char *) "mask", NULL
15939 };
15940
15941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15943 if (!SWIG_IsOK(res1)) {
15944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15945 }
15946 arg1 = reinterpret_cast< wxImage * >(argp1);
15947 if (obj1) {
15948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15949 if (!SWIG_IsOK(ecode2)) {
15950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15951 }
15952 arg2 = static_cast< bool >(val2);
15953 }
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 (arg1)->SetMask(arg2);
15957 wxPyEndAllowThreads(__tstate);
15958 if (PyErr_Occurred()) SWIG_fail;
15959 }
15960 resultobj = SWIG_Py_Void();
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15968 PyObject *resultobj = 0;
15969 wxImage *arg1 = (wxImage *) 0 ;
15970 bool result;
15971 void *argp1 = 0 ;
15972 int res1 = 0 ;
15973 PyObject *swig_obj[1] ;
15974
15975 if (!args) SWIG_fail;
15976 swig_obj[0] = args;
15977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15978 if (!SWIG_IsOK(res1)) {
15979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15980 }
15981 arg1 = reinterpret_cast< wxImage * >(argp1);
15982 {
15983 PyThreadState* __tstate = wxPyBeginAllowThreads();
15984 result = (bool)(arg1)->HasMask();
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 {
15989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15990 }
15991 return resultobj;
15992 fail:
15993 return NULL;
15994 }
15995
15996
15997 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15998 PyObject *resultobj = 0;
15999 wxImage *arg1 = (wxImage *) 0 ;
16000 double arg2 ;
16001 wxPoint *arg3 = 0 ;
16002 bool arg4 = (bool) true ;
16003 wxPoint *arg5 = (wxPoint *) NULL ;
16004 SwigValueWrapper<wxImage > result;
16005 void *argp1 = 0 ;
16006 int res1 = 0 ;
16007 double val2 ;
16008 int ecode2 = 0 ;
16009 wxPoint temp3 ;
16010 bool val4 ;
16011 int ecode4 = 0 ;
16012 void *argp5 = 0 ;
16013 int res5 = 0 ;
16014 PyObject * obj0 = 0 ;
16015 PyObject * obj1 = 0 ;
16016 PyObject * obj2 = 0 ;
16017 PyObject * obj3 = 0 ;
16018 PyObject * obj4 = 0 ;
16019 char * kwnames[] = {
16020 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16021 };
16022
16023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16025 if (!SWIG_IsOK(res1)) {
16026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16027 }
16028 arg1 = reinterpret_cast< wxImage * >(argp1);
16029 ecode2 = SWIG_AsVal_double(obj1, &val2);
16030 if (!SWIG_IsOK(ecode2)) {
16031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16032 }
16033 arg2 = static_cast< double >(val2);
16034 {
16035 arg3 = &temp3;
16036 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16037 }
16038 if (obj3) {
16039 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16040 if (!SWIG_IsOK(ecode4)) {
16041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16042 }
16043 arg4 = static_cast< bool >(val4);
16044 }
16045 if (obj4) {
16046 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16047 if (!SWIG_IsOK(res5)) {
16048 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16049 }
16050 arg5 = reinterpret_cast< wxPoint * >(argp5);
16051 }
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16066 PyObject *resultobj = 0;
16067 wxImage *arg1 = (wxImage *) 0 ;
16068 bool arg2 = (bool) true ;
16069 SwigValueWrapper<wxImage > result;
16070 void *argp1 = 0 ;
16071 int res1 = 0 ;
16072 bool val2 ;
16073 int ecode2 = 0 ;
16074 PyObject * obj0 = 0 ;
16075 PyObject * obj1 = 0 ;
16076 char * kwnames[] = {
16077 (char *) "self",(char *) "clockwise", NULL
16078 };
16079
16080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16082 if (!SWIG_IsOK(res1)) {
16083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16084 }
16085 arg1 = reinterpret_cast< wxImage * >(argp1);
16086 if (obj1) {
16087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16088 if (!SWIG_IsOK(ecode2)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16090 }
16091 arg2 = static_cast< bool >(val2);
16092 }
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = (arg1)->Rotate90(arg2);
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16100 return resultobj;
16101 fail:
16102 return NULL;
16103 }
16104
16105
16106 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16107 PyObject *resultobj = 0;
16108 wxImage *arg1 = (wxImage *) 0 ;
16109 bool arg2 = (bool) true ;
16110 SwigValueWrapper<wxImage > result;
16111 void *argp1 = 0 ;
16112 int res1 = 0 ;
16113 bool val2 ;
16114 int ecode2 = 0 ;
16115 PyObject * obj0 = 0 ;
16116 PyObject * obj1 = 0 ;
16117 char * kwnames[] = {
16118 (char *) "self",(char *) "horizontally", NULL
16119 };
16120
16121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16125 }
16126 arg1 = reinterpret_cast< wxImage * >(argp1);
16127 if (obj1) {
16128 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16129 if (!SWIG_IsOK(ecode2)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16131 }
16132 arg2 = static_cast< bool >(val2);
16133 }
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = (arg1)->Mirror(arg2);
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16148 PyObject *resultobj = 0;
16149 wxImage *arg1 = (wxImage *) 0 ;
16150 byte arg2 ;
16151 byte arg3 ;
16152 byte arg4 ;
16153 byte arg5 ;
16154 byte arg6 ;
16155 byte arg7 ;
16156 void *argp1 = 0 ;
16157 int res1 = 0 ;
16158 unsigned char val2 ;
16159 int ecode2 = 0 ;
16160 unsigned char val3 ;
16161 int ecode3 = 0 ;
16162 unsigned char val4 ;
16163 int ecode4 = 0 ;
16164 unsigned char val5 ;
16165 int ecode5 = 0 ;
16166 unsigned char val6 ;
16167 int ecode6 = 0 ;
16168 unsigned char val7 ;
16169 int ecode7 = 0 ;
16170 PyObject * obj0 = 0 ;
16171 PyObject * obj1 = 0 ;
16172 PyObject * obj2 = 0 ;
16173 PyObject * obj3 = 0 ;
16174 PyObject * obj4 = 0 ;
16175 PyObject * obj5 = 0 ;
16176 PyObject * obj6 = 0 ;
16177 char * kwnames[] = {
16178 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16179 };
16180
16181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16183 if (!SWIG_IsOK(res1)) {
16184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16185 }
16186 arg1 = reinterpret_cast< wxImage * >(argp1);
16187 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16188 if (!SWIG_IsOK(ecode2)) {
16189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16190 }
16191 arg2 = static_cast< byte >(val2);
16192 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16193 if (!SWIG_IsOK(ecode3)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16195 }
16196 arg3 = static_cast< byte >(val3);
16197 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16198 if (!SWIG_IsOK(ecode4)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16200 }
16201 arg4 = static_cast< byte >(val4);
16202 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16203 if (!SWIG_IsOK(ecode5)) {
16204 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16205 }
16206 arg5 = static_cast< byte >(val5);
16207 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16208 if (!SWIG_IsOK(ecode6)) {
16209 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16210 }
16211 arg6 = static_cast< byte >(val6);
16212 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16213 if (!SWIG_IsOK(ecode7)) {
16214 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16215 }
16216 arg7 = static_cast< byte >(val7);
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 resultobj = SWIG_Py_Void();
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj = 0;
16232 wxImage *arg1 = (wxImage *) 0 ;
16233 double arg2 = (double) 0.299 ;
16234 double arg3 = (double) 0.587 ;
16235 double arg4 = (double) 0.114 ;
16236 SwigValueWrapper<wxImage > result;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 double val2 ;
16240 int ecode2 = 0 ;
16241 double val3 ;
16242 int ecode3 = 0 ;
16243 double val4 ;
16244 int ecode4 = 0 ;
16245 PyObject * obj0 = 0 ;
16246 PyObject * obj1 = 0 ;
16247 PyObject * obj2 = 0 ;
16248 PyObject * obj3 = 0 ;
16249 char * kwnames[] = {
16250 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16251 };
16252
16253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16257 }
16258 arg1 = reinterpret_cast< wxImage * >(argp1);
16259 if (obj1) {
16260 ecode2 = SWIG_AsVal_double(obj1, &val2);
16261 if (!SWIG_IsOK(ecode2)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16263 }
16264 arg2 = static_cast< double >(val2);
16265 }
16266 if (obj2) {
16267 ecode3 = SWIG_AsVal_double(obj2, &val3);
16268 if (!SWIG_IsOK(ecode3)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16270 }
16271 arg3 = static_cast< double >(val3);
16272 }
16273 if (obj3) {
16274 ecode4 = SWIG_AsVal_double(obj3, &val4);
16275 if (!SWIG_IsOK(ecode4)) {
16276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16277 }
16278 arg4 = static_cast< double >(val4);
16279 }
16280 {
16281 PyThreadState* __tstate = wxPyBeginAllowThreads();
16282 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj = 0;
16295 wxImage *arg1 = (wxImage *) 0 ;
16296 byte arg2 ;
16297 byte arg3 ;
16298 byte arg4 ;
16299 SwigValueWrapper<wxImage > result;
16300 void *argp1 = 0 ;
16301 int res1 = 0 ;
16302 unsigned char val2 ;
16303 int ecode2 = 0 ;
16304 unsigned char val3 ;
16305 int ecode3 = 0 ;
16306 unsigned char val4 ;
16307 int ecode4 = 0 ;
16308 PyObject * obj0 = 0 ;
16309 PyObject * obj1 = 0 ;
16310 PyObject * obj2 = 0 ;
16311 PyObject * obj3 = 0 ;
16312 char * kwnames[] = {
16313 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16314 };
16315
16316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16318 if (!SWIG_IsOK(res1)) {
16319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16320 }
16321 arg1 = reinterpret_cast< wxImage * >(argp1);
16322 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16323 if (!SWIG_IsOK(ecode2)) {
16324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16325 }
16326 arg2 = static_cast< byte >(val2);
16327 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16328 if (!SWIG_IsOK(ecode3)) {
16329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16330 }
16331 arg3 = static_cast< byte >(val3);
16332 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16333 if (!SWIG_IsOK(ecode4)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16335 }
16336 arg4 = static_cast< byte >(val4);
16337 {
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16351 PyObject *resultobj = 0;
16352 wxImage *arg1 = (wxImage *) 0 ;
16353 wxString *arg2 = 0 ;
16354 wxString *arg3 = 0 ;
16355 void *argp1 = 0 ;
16356 int res1 = 0 ;
16357 bool temp2 = false ;
16358 bool temp3 = false ;
16359 PyObject * obj0 = 0 ;
16360 PyObject * obj1 = 0 ;
16361 PyObject * obj2 = 0 ;
16362 char * kwnames[] = {
16363 (char *) "self",(char *) "name",(char *) "value", NULL
16364 };
16365
16366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) 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_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 {
16373 arg2 = wxString_in_helper(obj1);
16374 if (arg2 == NULL) SWIG_fail;
16375 temp2 = true;
16376 }
16377 {
16378 arg3 = wxString_in_helper(obj2);
16379 if (arg3 == NULL) SWIG_fail;
16380 temp3 = true;
16381 }
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 resultobj = SWIG_Py_Void();
16389 {
16390 if (temp2)
16391 delete arg2;
16392 }
16393 {
16394 if (temp3)
16395 delete arg3;
16396 }
16397 return resultobj;
16398 fail:
16399 {
16400 if (temp2)
16401 delete arg2;
16402 }
16403 {
16404 if (temp3)
16405 delete arg3;
16406 }
16407 return NULL;
16408 }
16409
16410
16411 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16412 PyObject *resultobj = 0;
16413 wxImage *arg1 = (wxImage *) 0 ;
16414 wxString *arg2 = 0 ;
16415 int arg3 ;
16416 void *argp1 = 0 ;
16417 int res1 = 0 ;
16418 bool temp2 = false ;
16419 int val3 ;
16420 int ecode3 = 0 ;
16421 PyObject * obj0 = 0 ;
16422 PyObject * obj1 = 0 ;
16423 PyObject * obj2 = 0 ;
16424 char * kwnames[] = {
16425 (char *) "self",(char *) "name",(char *) "value", NULL
16426 };
16427
16428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16430 if (!SWIG_IsOK(res1)) {
16431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16432 }
16433 arg1 = reinterpret_cast< wxImage * >(argp1);
16434 {
16435 arg2 = wxString_in_helper(obj1);
16436 if (arg2 == NULL) SWIG_fail;
16437 temp2 = true;
16438 }
16439 ecode3 = SWIG_AsVal_int(obj2, &val3);
16440 if (!SWIG_IsOK(ecode3)) {
16441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16442 }
16443 arg3 = static_cast< int >(val3);
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 (arg1)->SetOption((wxString const &)*arg2,arg3);
16447 wxPyEndAllowThreads(__tstate);
16448 if (PyErr_Occurred()) SWIG_fail;
16449 }
16450 resultobj = SWIG_Py_Void();
16451 {
16452 if (temp2)
16453 delete arg2;
16454 }
16455 return resultobj;
16456 fail:
16457 {
16458 if (temp2)
16459 delete arg2;
16460 }
16461 return NULL;
16462 }
16463
16464
16465 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj = 0;
16467 wxImage *arg1 = (wxImage *) 0 ;
16468 wxString *arg2 = 0 ;
16469 wxString result;
16470 void *argp1 = 0 ;
16471 int res1 = 0 ;
16472 bool temp2 = false ;
16473 PyObject * obj0 = 0 ;
16474 PyObject * obj1 = 0 ;
16475 char * kwnames[] = {
16476 (char *) "self",(char *) "name", NULL
16477 };
16478
16479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16481 if (!SWIG_IsOK(res1)) {
16482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16483 }
16484 arg1 = reinterpret_cast< wxImage * >(argp1);
16485 {
16486 arg2 = wxString_in_helper(obj1);
16487 if (arg2 == NULL) SWIG_fail;
16488 temp2 = true;
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 #if wxUSE_UNICODE
16498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16499 #else
16500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16501 #endif
16502 }
16503 {
16504 if (temp2)
16505 delete arg2;
16506 }
16507 return resultobj;
16508 fail:
16509 {
16510 if (temp2)
16511 delete arg2;
16512 }
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxImage *arg1 = (wxImage *) 0 ;
16520 wxString *arg2 = 0 ;
16521 int result;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 bool temp2 = false ;
16525 PyObject * obj0 = 0 ;
16526 PyObject * obj1 = 0 ;
16527 char * kwnames[] = {
16528 (char *) "self",(char *) "name", NULL
16529 };
16530
16531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16533 if (!SWIG_IsOK(res1)) {
16534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16535 }
16536 arg1 = reinterpret_cast< wxImage * >(argp1);
16537 {
16538 arg2 = wxString_in_helper(obj1);
16539 if (arg2 == NULL) SWIG_fail;
16540 temp2 = true;
16541 }
16542 {
16543 PyThreadState* __tstate = wxPyBeginAllowThreads();
16544 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16545 wxPyEndAllowThreads(__tstate);
16546 if (PyErr_Occurred()) SWIG_fail;
16547 }
16548 resultobj = SWIG_From_int(static_cast< int >(result));
16549 {
16550 if (temp2)
16551 delete arg2;
16552 }
16553 return resultobj;
16554 fail:
16555 {
16556 if (temp2)
16557 delete arg2;
16558 }
16559 return NULL;
16560 }
16561
16562
16563 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj = 0;
16565 wxImage *arg1 = (wxImage *) 0 ;
16566 wxString *arg2 = 0 ;
16567 bool result;
16568 void *argp1 = 0 ;
16569 int res1 = 0 ;
16570 bool temp2 = false ;
16571 PyObject * obj0 = 0 ;
16572 PyObject * obj1 = 0 ;
16573 char * kwnames[] = {
16574 (char *) "self",(char *) "name", NULL
16575 };
16576
16577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16579 if (!SWIG_IsOK(res1)) {
16580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16581 }
16582 arg1 = reinterpret_cast< wxImage * >(argp1);
16583 {
16584 arg2 = wxString_in_helper(obj1);
16585 if (arg2 == NULL) SWIG_fail;
16586 temp2 = true;
16587 }
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 {
16598 if (temp2)
16599 delete arg2;
16600 }
16601 return resultobj;
16602 fail:
16603 {
16604 if (temp2)
16605 delete arg2;
16606 }
16607 return NULL;
16608 }
16609
16610
16611 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj = 0;
16613 wxImage *arg1 = (wxImage *) 0 ;
16614 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16615 unsigned long result;
16616 void *argp1 = 0 ;
16617 int res1 = 0 ;
16618 unsigned long val2 ;
16619 int ecode2 = 0 ;
16620 PyObject * obj0 = 0 ;
16621 PyObject * obj1 = 0 ;
16622 char * kwnames[] = {
16623 (char *) "self",(char *) "stopafter", NULL
16624 };
16625
16626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16630 }
16631 arg1 = reinterpret_cast< wxImage * >(argp1);
16632 if (obj1) {
16633 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16634 if (!SWIG_IsOK(ecode2)) {
16635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16636 }
16637 arg2 = static_cast< unsigned long >(val2);
16638 }
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 result = (unsigned long)(arg1)->CountColours(arg2);
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 wxImageHistogram *arg2 = 0 ;
16656 unsigned long result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 void *argp2 = 0 ;
16660 int res2 = 0 ;
16661 PyObject * obj0 = 0 ;
16662 PyObject * obj1 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "self",(char *) "h", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16671 }
16672 arg1 = reinterpret_cast< wxImage * >(argp1);
16673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16674 if (!SWIG_IsOK(res2)) {
16675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16676 }
16677 if (!argp2) {
16678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16679 }
16680 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj = 0;
16696 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject * obj0 = 0 ;
16700 char * kwnames[] = {
16701 (char *) "handler", NULL
16702 };
16703
16704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16706 if (!SWIG_IsOK(res1)) {
16707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16708 }
16709 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 wxImage::AddHandler(arg1);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_Py_Void();
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 PyObject * obj0 = 0 ;
16729 char * kwnames[] = {
16730 (char *) "handler", NULL
16731 };
16732
16733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16735 if (!SWIG_IsOK(res1)) {
16736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16737 }
16738 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 wxImage::InsertHandler(arg1);
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_Py_Void();
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxString *arg1 = 0 ;
16755 bool result;
16756 bool temp1 = false ;
16757 PyObject * obj0 = 0 ;
16758 char * kwnames[] = {
16759 (char *) "name", NULL
16760 };
16761
16762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16763 {
16764 arg1 = wxString_in_helper(obj0);
16765 if (arg1 == NULL) SWIG_fail;
16766 temp1 = true;
16767 }
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 {
16775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16776 }
16777 {
16778 if (temp1)
16779 delete arg1;
16780 }
16781 return resultobj;
16782 fail:
16783 {
16784 if (temp1)
16785 delete arg1;
16786 }
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16792 PyObject *resultobj = 0;
16793 PyObject *result = 0 ;
16794
16795 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = (PyObject *)wxImage_GetHandlers();
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 resultobj = result;
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16810 PyObject *resultobj = 0;
16811 wxString result;
16812
16813 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16814 {
16815 PyThreadState* __tstate = wxPyBeginAllowThreads();
16816 result = wxImage::GetImageExtWildcard();
16817 wxPyEndAllowThreads(__tstate);
16818 if (PyErr_Occurred()) SWIG_fail;
16819 }
16820 {
16821 #if wxUSE_UNICODE
16822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16823 #else
16824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16825 #endif
16826 }
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj = 0;
16835 wxImage *arg1 = (wxImage *) 0 ;
16836 int arg2 = (int) -1 ;
16837 wxBitmap result;
16838 void *argp1 = 0 ;
16839 int res1 = 0 ;
16840 int val2 ;
16841 int ecode2 = 0 ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char * kwnames[] = {
16845 (char *) "self",(char *) "depth", NULL
16846 };
16847
16848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16850 if (!SWIG_IsOK(res1)) {
16851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16852 }
16853 arg1 = reinterpret_cast< wxImage * >(argp1);
16854 if (obj1) {
16855 ecode2 = SWIG_AsVal_int(obj1, &val2);
16856 if (!SWIG_IsOK(ecode2)) {
16857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16858 }
16859 arg2 = static_cast< int >(val2);
16860 }
16861 {
16862 if (!wxPyCheckForApp()) SWIG_fail;
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = wxImage_ConvertToBitmap(arg1,arg2);
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16876 PyObject *resultobj = 0;
16877 wxImage *arg1 = (wxImage *) 0 ;
16878 byte arg2 ;
16879 byte arg3 ;
16880 byte arg4 ;
16881 wxBitmap result;
16882 void *argp1 = 0 ;
16883 int res1 = 0 ;
16884 unsigned char val2 ;
16885 int ecode2 = 0 ;
16886 unsigned char val3 ;
16887 int ecode3 = 0 ;
16888 unsigned char val4 ;
16889 int ecode4 = 0 ;
16890 PyObject * obj0 = 0 ;
16891 PyObject * obj1 = 0 ;
16892 PyObject * obj2 = 0 ;
16893 PyObject * obj3 = 0 ;
16894 char * kwnames[] = {
16895 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16896 };
16897
16898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16900 if (!SWIG_IsOK(res1)) {
16901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16902 }
16903 arg1 = reinterpret_cast< wxImage * >(argp1);
16904 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16905 if (!SWIG_IsOK(ecode2)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16907 }
16908 arg2 = static_cast< byte >(val2);
16909 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16910 if (!SWIG_IsOK(ecode3)) {
16911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16912 }
16913 arg3 = static_cast< byte >(val3);
16914 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16915 if (!SWIG_IsOK(ecode4)) {
16916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16917 }
16918 arg4 = static_cast< byte >(val4);
16919 {
16920 if (!wxPyCheckForApp()) SWIG_fail;
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16934 PyObject *resultobj = 0;
16935 wxImage *arg1 = (wxImage *) 0 ;
16936 double arg2 ;
16937 void *argp1 = 0 ;
16938 int res1 = 0 ;
16939 double val2 ;
16940 int ecode2 = 0 ;
16941 PyObject * obj0 = 0 ;
16942 PyObject * obj1 = 0 ;
16943 char * kwnames[] = {
16944 (char *) "self",(char *) "angle", NULL
16945 };
16946
16947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16949 if (!SWIG_IsOK(res1)) {
16950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16951 }
16952 arg1 = reinterpret_cast< wxImage * >(argp1);
16953 ecode2 = SWIG_AsVal_double(obj1, &val2);
16954 if (!SWIG_IsOK(ecode2)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16956 }
16957 arg2 = static_cast< double >(val2);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 (arg1)->RotateHue(arg2);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_Py_Void();
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj = 0;
16973 wxImage_RGBValue arg1 ;
16974 wxImage_HSVValue result;
16975 void *argp1 ;
16976 int res1 = 0 ;
16977 PyObject * obj0 = 0 ;
16978 char * kwnames[] = {
16979 (char *) "rgb", NULL
16980 };
16981
16982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16983 {
16984 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16985 if (!SWIG_IsOK(res1)) {
16986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16987 }
16988 if (!argp1) {
16989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16990 } else {
16991 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16992 arg1 = *temp;
16993 if (SWIG_IsNewObj(res1)) delete temp;
16994 }
16995 }
16996 {
16997 PyThreadState* __tstate = wxPyBeginAllowThreads();
16998 result = wxImage::RGBtoHSV(arg1);
16999 wxPyEndAllowThreads(__tstate);
17000 if (PyErr_Occurred()) SWIG_fail;
17001 }
17002 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxImage_HSVValue arg1 ;
17012 wxImage_RGBValue result;
17013 void *argp1 ;
17014 int res1 = 0 ;
17015 PyObject * obj0 = 0 ;
17016 char * kwnames[] = {
17017 (char *) "hsv", NULL
17018 };
17019
17020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17021 {
17022 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17023 if (!SWIG_IsOK(res1)) {
17024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17025 }
17026 if (!argp1) {
17027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17028 } else {
17029 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17030 arg1 = *temp;
17031 if (SWIG_IsNewObj(res1)) delete temp;
17032 }
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = wxImage::HSVtoRGB(arg1);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17041 return resultobj;
17042 fail:
17043 return NULL;
17044 }
17045
17046
17047 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17048 PyObject *obj;
17049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17050 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17051 return SWIG_Py_Void();
17052 }
17053
17054 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17055 return SWIG_Python_InitShadowInstance(args);
17056 }
17057
17058 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj = 0;
17060 int arg1 ;
17061 int arg2 ;
17062 buffer arg3 ;
17063 int arg4 ;
17064 buffer arg5 = (buffer) NULL ;
17065 int arg6 = (int) 0 ;
17066 wxImage *result = 0 ;
17067 int val1 ;
17068 int ecode1 = 0 ;
17069 int val2 ;
17070 int ecode2 = 0 ;
17071 Py_ssize_t temp3 ;
17072 Py_ssize_t temp5 ;
17073 PyObject * obj0 = 0 ;
17074 PyObject * obj1 = 0 ;
17075 PyObject * obj2 = 0 ;
17076 PyObject * obj3 = 0 ;
17077 char * kwnames[] = {
17078 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17079 };
17080
17081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17082 ecode1 = SWIG_AsVal_int(obj0, &val1);
17083 if (!SWIG_IsOK(ecode1)) {
17084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17085 }
17086 arg1 = static_cast< int >(val1);
17087 ecode2 = SWIG_AsVal_int(obj1, &val2);
17088 if (!SWIG_IsOK(ecode2)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17090 }
17091 arg2 = static_cast< int >(val2);
17092 {
17093 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17094 arg4 = (int)temp3;
17095 }
17096 if (obj3) {
17097 {
17098 if (obj3 != Py_None) {
17099 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17100 arg6 = (int)temp5;
17101 }
17102 }
17103 }
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 {
17111 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17112 }
17113 return resultobj;
17114 fail:
17115 return NULL;
17116 }
17117
17118
17119 SWIGINTERN int NullImage_set(PyObject *) {
17120 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17121 return 1;
17122 }
17123
17124
17125 SWIGINTERN PyObject *NullImage_get(void) {
17126 PyObject *pyobj = 0;
17127
17128 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17129 return pyobj;
17130 }
17131
17132
17133 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17134 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17135 return 1;
17136 }
17137
17138
17139 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17140 PyObject *pyobj = 0;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17154 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17155 return 1;
17156 }
17157
17158
17159 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17160 PyObject *pyobj = 0;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17174 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17175 return 1;
17176 }
17177
17178
17179 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17180 PyObject *pyobj = 0;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17194 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17195 return 1;
17196 }
17197
17198
17199 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17200 PyObject *pyobj = 0;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17214 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17215 return 1;
17216 }
17217
17218
17219 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17220 PyObject *pyobj = 0;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17234 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17235 return 1;
17236 }
17237
17238
17239 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17240 PyObject *pyobj = 0;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17254 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17255 return 1;
17256 }
17257
17258
17259 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17260 PyObject *pyobj = 0;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17274 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17275 return 1;
17276 }
17277
17278
17279 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17280 PyObject *pyobj = 0;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17294 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17295 return 1;
17296 }
17297
17298
17299 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17300 PyObject *pyobj = 0;
17301
17302 {
17303 #if wxUSE_UNICODE
17304 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17305 #else
17306 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17307 #endif
17308 }
17309 return pyobj;
17310 }
17311
17312
17313 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17314 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17315 return 1;
17316 }
17317
17318
17319 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17320 PyObject *pyobj = 0;
17321
17322 {
17323 #if wxUSE_UNICODE
17324 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17325 #else
17326 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17327 #endif
17328 }
17329 return pyobj;
17330 }
17331
17332
17333 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17334 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17335 return 1;
17336 }
17337
17338
17339 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17340 PyObject *pyobj = 0;
17341
17342 {
17343 #if wxUSE_UNICODE
17344 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17345 #else
17346 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17347 #endif
17348 }
17349 return pyobj;
17350 }
17351
17352
17353 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17354 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17355 return 1;
17356 }
17357
17358
17359 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17360 PyObject *pyobj = 0;
17361
17362 {
17363 #if wxUSE_UNICODE
17364 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17365 #else
17366 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17367 #endif
17368 }
17369 return pyobj;
17370 }
17371
17372
17373 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17374 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17375 return 1;
17376 }
17377
17378
17379 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17380 PyObject *pyobj = 0;
17381
17382 {
17383 #if wxUSE_UNICODE
17384 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17385 #else
17386 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17387 #endif
17388 }
17389 return pyobj;
17390 }
17391
17392
17393 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17394 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17395 return 1;
17396 }
17397
17398
17399 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17400 PyObject *pyobj = 0;
17401
17402 {
17403 #if wxUSE_UNICODE
17404 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17405 #else
17406 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17407 #endif
17408 }
17409 return pyobj;
17410 }
17411
17412
17413 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17414 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17415 return 1;
17416 }
17417
17418
17419 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17420 PyObject *pyobj = 0;
17421
17422 {
17423 #if wxUSE_UNICODE
17424 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17425 #else
17426 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17427 #endif
17428 }
17429 return pyobj;
17430 }
17431
17432
17433 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17434 PyObject *resultobj = 0;
17435 wxBMPHandler *result = 0 ;
17436
17437 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (wxBMPHandler *)new wxBMPHandler();
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *obj;
17453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17454 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17455 return SWIG_Py_Void();
17456 }
17457
17458 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17459 return SWIG_Python_InitShadowInstance(args);
17460 }
17461
17462 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17463 PyObject *resultobj = 0;
17464 wxICOHandler *result = 0 ;
17465
17466 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (wxICOHandler *)new wxICOHandler();
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17474 return resultobj;
17475 fail:
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *obj;
17482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17483 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17484 return SWIG_Py_Void();
17485 }
17486
17487 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 return SWIG_Python_InitShadowInstance(args);
17489 }
17490
17491 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *resultobj = 0;
17493 wxCURHandler *result = 0 ;
17494
17495 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (wxCURHandler *)new wxCURHandler();
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *obj;
17511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17512 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17513 return SWIG_Py_Void();
17514 }
17515
17516 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 return SWIG_Python_InitShadowInstance(args);
17518 }
17519
17520 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *resultobj = 0;
17522 wxANIHandler *result = 0 ;
17523
17524 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (wxANIHandler *)new wxANIHandler();
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *obj;
17540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17541 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17542 return SWIG_Py_Void();
17543 }
17544
17545 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 return SWIG_Python_InitShadowInstance(args);
17547 }
17548
17549 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17550 PyObject *resultobj = 0;
17551 wxPNGHandler *result = 0 ;
17552
17553 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (wxPNGHandler *)new wxPNGHandler();
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17568 PyObject *obj;
17569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17571 return SWIG_Py_Void();
17572 }
17573
17574 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17575 return SWIG_Python_InitShadowInstance(args);
17576 }
17577
17578 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 PyObject *resultobj = 0;
17580 wxGIFHandler *result = 0 ;
17581
17582 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (wxGIFHandler *)new wxGIFHandler();
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17590 return resultobj;
17591 fail:
17592 return NULL;
17593 }
17594
17595
17596 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17597 PyObject *obj;
17598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17599 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17600 return SWIG_Py_Void();
17601 }
17602
17603 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17604 return SWIG_Python_InitShadowInstance(args);
17605 }
17606
17607 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17608 PyObject *resultobj = 0;
17609 wxPCXHandler *result = 0 ;
17610
17611 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17612 {
17613 PyThreadState* __tstate = wxPyBeginAllowThreads();
17614 result = (wxPCXHandler *)new wxPCXHandler();
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *obj;
17627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17628 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17629 return SWIG_Py_Void();
17630 }
17631
17632 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17633 return SWIG_Python_InitShadowInstance(args);
17634 }
17635
17636 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *resultobj = 0;
17638 wxJPEGHandler *result = 0 ;
17639
17640 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxJPEGHandler *)new wxJPEGHandler();
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17655 PyObject *obj;
17656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17657 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17658 return SWIG_Py_Void();
17659 }
17660
17661 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17662 return SWIG_Python_InitShadowInstance(args);
17663 }
17664
17665 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17666 PyObject *resultobj = 0;
17667 wxPNMHandler *result = 0 ;
17668
17669 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (wxPNMHandler *)new wxPNMHandler();
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17684 PyObject *obj;
17685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17687 return SWIG_Py_Void();
17688 }
17689
17690 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17691 return SWIG_Python_InitShadowInstance(args);
17692 }
17693
17694 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17695 PyObject *resultobj = 0;
17696 wxXPMHandler *result = 0 ;
17697
17698 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (wxXPMHandler *)new wxXPMHandler();
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *obj;
17714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17715 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17716 return SWIG_Py_Void();
17717 }
17718
17719 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17720 return SWIG_Python_InitShadowInstance(args);
17721 }
17722
17723 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *resultobj = 0;
17725 wxTIFFHandler *result = 0 ;
17726
17727 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 result = (wxTIFFHandler *)new wxTIFFHandler();
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17742 PyObject *obj;
17743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17744 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17745 return SWIG_Py_Void();
17746 }
17747
17748 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17749 return SWIG_Python_InitShadowInstance(args);
17750 }
17751
17752 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17753 PyObject *resultobj = 0;
17754 wxImage *arg1 = 0 ;
17755 wxImage *arg2 = 0 ;
17756 int arg3 = (int) 236 ;
17757 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17758 bool result;
17759 void *argp1 = 0 ;
17760 int res1 = 0 ;
17761 void *argp2 = 0 ;
17762 int res2 = 0 ;
17763 int val3 ;
17764 int ecode3 = 0 ;
17765 int val4 ;
17766 int ecode4 = 0 ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 PyObject * obj2 = 0 ;
17770 PyObject * obj3 = 0 ;
17771 char * kwnames[] = {
17772 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17773 };
17774
17775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17777 if (!SWIG_IsOK(res1)) {
17778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17779 }
17780 if (!argp1) {
17781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17782 }
17783 arg1 = reinterpret_cast< wxImage * >(argp1);
17784 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17785 if (!SWIG_IsOK(res2)) {
17786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17787 }
17788 if (!argp2) {
17789 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17790 }
17791 arg2 = reinterpret_cast< wxImage * >(argp2);
17792 if (obj2) {
17793 ecode3 = SWIG_AsVal_int(obj2, &val3);
17794 if (!SWIG_IsOK(ecode3)) {
17795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17796 }
17797 arg3 = static_cast< int >(val3);
17798 }
17799 if (obj3) {
17800 ecode4 = SWIG_AsVal_int(obj3, &val4);
17801 if (!SWIG_IsOK(ecode4)) {
17802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17803 }
17804 arg4 = static_cast< int >(val4);
17805 }
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17809 wxPyEndAllowThreads(__tstate);
17810 if (PyErr_Occurred()) SWIG_fail;
17811 }
17812 {
17813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17814 }
17815 return resultobj;
17816 fail:
17817 return NULL;
17818 }
17819
17820
17821 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17822 PyObject *obj;
17823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17824 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17825 return SWIG_Py_Void();
17826 }
17827
17828 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17829 PyObject *resultobj = 0;
17830 wxEvtHandler *result = 0 ;
17831
17832 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 result = (wxEvtHandler *)new wxEvtHandler();
17836 wxPyEndAllowThreads(__tstate);
17837 if (PyErr_Occurred()) SWIG_fail;
17838 }
17839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17847 PyObject *resultobj = 0;
17848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17849 wxEvtHandler *result = 0 ;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 PyObject *swig_obj[1] ;
17853
17854 if (!args) SWIG_fail;
17855 swig_obj[0] = args;
17856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17859 }
17860 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 resultobj = wxPyMake_wxObject(result, 0);
17869 }
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17877 PyObject *resultobj = 0;
17878 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17879 wxEvtHandler *result = 0 ;
17880 void *argp1 = 0 ;
17881 int res1 = 0 ;
17882 PyObject *swig_obj[1] ;
17883
17884 if (!args) SWIG_fail;
17885 swig_obj[0] = args;
17886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17887 if (!SWIG_IsOK(res1)) {
17888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17889 }
17890 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 resultobj = wxPyMake_wxObject(result, 0);
17899 }
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj = 0;
17908 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17909 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17910 void *argp1 = 0 ;
17911 int res1 = 0 ;
17912 void *argp2 = 0 ;
17913 int res2 = 0 ;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 char * kwnames[] = {
17917 (char *) "self",(char *) "handler", NULL
17918 };
17919
17920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17922 if (!SWIG_IsOK(res1)) {
17923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17924 }
17925 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res2)) {
17928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 (arg1)->SetNextHandler(arg2);
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 resultobj = SWIG_Py_Void();
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj = 0;
17946 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17947 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17948 void *argp1 = 0 ;
17949 int res1 = 0 ;
17950 void *argp2 = 0 ;
17951 int res2 = 0 ;
17952 PyObject * obj0 = 0 ;
17953 PyObject * obj1 = 0 ;
17954 char * kwnames[] = {
17955 (char *) "self",(char *) "handler", NULL
17956 };
17957
17958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17960 if (!SWIG_IsOK(res1)) {
17961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17962 }
17963 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17965 if (!SWIG_IsOK(res2)) {
17966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17967 }
17968 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 (arg1)->SetPreviousHandler(arg2);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_Py_Void();
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983 PyObject *resultobj = 0;
17984 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17985 bool result;
17986 void *argp1 = 0 ;
17987 int res1 = 0 ;
17988 PyObject *swig_obj[1] ;
17989
17990 if (!args) SWIG_fail;
17991 swig_obj[0] = args;
17992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17993 if (!SWIG_IsOK(res1)) {
17994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17995 }
17996 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17997 {
17998 PyThreadState* __tstate = wxPyBeginAllowThreads();
17999 result = (bool)(arg1)->GetEvtHandlerEnabled();
18000 wxPyEndAllowThreads(__tstate);
18001 if (PyErr_Occurred()) SWIG_fail;
18002 }
18003 {
18004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18005 }
18006 return resultobj;
18007 fail:
18008 return NULL;
18009 }
18010
18011
18012 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18013 PyObject *resultobj = 0;
18014 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18015 bool arg2 ;
18016 void *argp1 = 0 ;
18017 int res1 = 0 ;
18018 bool val2 ;
18019 int ecode2 = 0 ;
18020 PyObject * obj0 = 0 ;
18021 PyObject * obj1 = 0 ;
18022 char * kwnames[] = {
18023 (char *) "self",(char *) "enabled", NULL
18024 };
18025
18026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18030 }
18031 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18033 if (!SWIG_IsOK(ecode2)) {
18034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18035 }
18036 arg2 = static_cast< bool >(val2);
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 (arg1)->SetEvtHandlerEnabled(arg2);
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = SWIG_Py_Void();
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18051 PyObject *resultobj = 0;
18052 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18053 wxEvent *arg2 = 0 ;
18054 bool result;
18055 void *argp1 = 0 ;
18056 int res1 = 0 ;
18057 void *argp2 = 0 ;
18058 int res2 = 0 ;
18059 PyObject * obj0 = 0 ;
18060 PyObject * obj1 = 0 ;
18061 char * kwnames[] = {
18062 (char *) "self",(char *) "event", NULL
18063 };
18064
18065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18067 if (!SWIG_IsOK(res1)) {
18068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18069 }
18070 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18072 if (!SWIG_IsOK(res2)) {
18073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18074 }
18075 if (!argp2) {
18076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18077 }
18078 arg2 = reinterpret_cast< wxEvent * >(argp2);
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = (bool)(arg1)->ProcessEvent(*arg2);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18087 }
18088 return resultobj;
18089 fail:
18090 return NULL;
18091 }
18092
18093
18094 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18095 PyObject *resultobj = 0;
18096 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18097 wxEvent *arg2 = 0 ;
18098 void *argp1 = 0 ;
18099 int res1 = 0 ;
18100 void *argp2 = 0 ;
18101 int res2 = 0 ;
18102 PyObject * obj0 = 0 ;
18103 PyObject * obj1 = 0 ;
18104 char * kwnames[] = {
18105 (char *) "self",(char *) "event", NULL
18106 };
18107
18108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18110 if (!SWIG_IsOK(res1)) {
18111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18112 }
18113 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18115 if (!SWIG_IsOK(res2)) {
18116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18117 }
18118 if (!argp2) {
18119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18120 }
18121 arg2 = reinterpret_cast< wxEvent * >(argp2);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 (arg1)->AddPendingEvent(*arg2);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = SWIG_Py_Void();
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18138 void *argp1 = 0 ;
18139 int res1 = 0 ;
18140 PyObject *swig_obj[1] ;
18141
18142 if (!args) SWIG_fail;
18143 swig_obj[0] = args;
18144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18147 }
18148 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 (arg1)->ProcessPendingEvents();
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj = 0;
18164 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18165 int arg2 ;
18166 int arg3 ;
18167 int arg4 ;
18168 PyObject *arg5 = (PyObject *) 0 ;
18169 void *argp1 = 0 ;
18170 int res1 = 0 ;
18171 int val2 ;
18172 int ecode2 = 0 ;
18173 int val3 ;
18174 int ecode3 = 0 ;
18175 int val4 ;
18176 int ecode4 = 0 ;
18177 PyObject * obj0 = 0 ;
18178 PyObject * obj1 = 0 ;
18179 PyObject * obj2 = 0 ;
18180 PyObject * obj3 = 0 ;
18181 PyObject * obj4 = 0 ;
18182 char * kwnames[] = {
18183 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18184 };
18185
18186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18188 if (!SWIG_IsOK(res1)) {
18189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18190 }
18191 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18192 ecode2 = SWIG_AsVal_int(obj1, &val2);
18193 if (!SWIG_IsOK(ecode2)) {
18194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18195 }
18196 arg2 = static_cast< int >(val2);
18197 ecode3 = SWIG_AsVal_int(obj2, &val3);
18198 if (!SWIG_IsOK(ecode3)) {
18199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18200 }
18201 arg3 = static_cast< int >(val3);
18202 ecode4 = SWIG_AsVal_int(obj3, &val4);
18203 if (!SWIG_IsOK(ecode4)) {
18204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18205 }
18206 arg4 = static_cast< int >(val4);
18207 arg5 = obj4;
18208 {
18209 PyThreadState* __tstate = wxPyBeginAllowThreads();
18210 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 resultobj = SWIG_Py_Void();
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj = 0;
18223 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18224 int arg2 ;
18225 int arg3 = (int) -1 ;
18226 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18227 bool result;
18228 void *argp1 = 0 ;
18229 int res1 = 0 ;
18230 int val2 ;
18231 int ecode2 = 0 ;
18232 int val3 ;
18233 int ecode3 = 0 ;
18234 int val4 ;
18235 int ecode4 = 0 ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 PyObject * obj2 = 0 ;
18239 PyObject * obj3 = 0 ;
18240 char * kwnames[] = {
18241 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18242 };
18243
18244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18246 if (!SWIG_IsOK(res1)) {
18247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18248 }
18249 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18250 ecode2 = SWIG_AsVal_int(obj1, &val2);
18251 if (!SWIG_IsOK(ecode2)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18253 }
18254 arg2 = static_cast< int >(val2);
18255 if (obj2) {
18256 ecode3 = SWIG_AsVal_int(obj2, &val3);
18257 if (!SWIG_IsOK(ecode3)) {
18258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18259 }
18260 arg3 = static_cast< int >(val3);
18261 }
18262 if (obj3) {
18263 ecode4 = SWIG_AsVal_int(obj3, &val4);
18264 if (!SWIG_IsOK(ecode4)) {
18265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18266 }
18267 arg4 = static_cast< wxEventType >(val4);
18268 }
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 {
18276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18277 }
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj = 0;
18286 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18287 PyObject *arg2 = (PyObject *) 0 ;
18288 bool arg3 = (bool) true ;
18289 void *argp1 = 0 ;
18290 int res1 = 0 ;
18291 bool val3 ;
18292 int ecode3 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 char * kwnames[] = {
18297 (char *) "self",(char *) "_self",(char *) "incref", NULL
18298 };
18299
18300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18304 }
18305 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18306 arg2 = obj1;
18307 if (obj2) {
18308 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18309 if (!SWIG_IsOK(ecode3)) {
18310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18311 }
18312 arg3 = static_cast< bool >(val3);
18313 }
18314 {
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18317 wxPyEndAllowThreads(__tstate);
18318 if (PyErr_Occurred()) SWIG_fail;
18319 }
18320 resultobj = SWIG_Py_Void();
18321 return resultobj;
18322 fail:
18323 return NULL;
18324 }
18325
18326
18327 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18328 PyObject *obj;
18329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18330 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18331 return SWIG_Py_Void();
18332 }
18333
18334 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18335 return SWIG_Python_InitShadowInstance(args);
18336 }
18337
18338 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18339 PyObject *resultobj = 0;
18340 wxEventType result;
18341
18342 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18343 {
18344 PyThreadState* __tstate = wxPyBeginAllowThreads();
18345 result = (wxEventType)wxNewEventType();
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 resultobj = SWIG_From_int(static_cast< int >(result));
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18357 PyObject *resultobj = 0;
18358 wxEvent *arg1 = (wxEvent *) 0 ;
18359 void *argp1 = 0 ;
18360 int res1 = 0 ;
18361 PyObject *swig_obj[1] ;
18362
18363 if (!args) SWIG_fail;
18364 swig_obj[0] = args;
18365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18366 if (!SWIG_IsOK(res1)) {
18367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18368 }
18369 arg1 = reinterpret_cast< wxEvent * >(argp1);
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 delete arg1;
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_Py_Void();
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj = 0;
18386 wxEvent *arg1 = (wxEvent *) 0 ;
18387 wxEventType arg2 ;
18388 void *argp1 = 0 ;
18389 int res1 = 0 ;
18390 int val2 ;
18391 int ecode2 = 0 ;
18392 PyObject * obj0 = 0 ;
18393 PyObject * obj1 = 0 ;
18394 char * kwnames[] = {
18395 (char *) "self",(char *) "typ", NULL
18396 };
18397
18398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18400 if (!SWIG_IsOK(res1)) {
18401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18402 }
18403 arg1 = reinterpret_cast< wxEvent * >(argp1);
18404 ecode2 = SWIG_AsVal_int(obj1, &val2);
18405 if (!SWIG_IsOK(ecode2)) {
18406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18407 }
18408 arg2 = static_cast< wxEventType >(val2);
18409 {
18410 PyThreadState* __tstate = wxPyBeginAllowThreads();
18411 (arg1)->SetEventType(arg2);
18412 wxPyEndAllowThreads(__tstate);
18413 if (PyErr_Occurred()) SWIG_fail;
18414 }
18415 resultobj = SWIG_Py_Void();
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18423 PyObject *resultobj = 0;
18424 wxEvent *arg1 = (wxEvent *) 0 ;
18425 wxEventType result;
18426 void *argp1 = 0 ;
18427 int res1 = 0 ;
18428 PyObject *swig_obj[1] ;
18429
18430 if (!args) SWIG_fail;
18431 swig_obj[0] = args;
18432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18433 if (!SWIG_IsOK(res1)) {
18434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18435 }
18436 arg1 = reinterpret_cast< wxEvent * >(argp1);
18437 {
18438 PyThreadState* __tstate = wxPyBeginAllowThreads();
18439 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18440 wxPyEndAllowThreads(__tstate);
18441 if (PyErr_Occurred()) SWIG_fail;
18442 }
18443 resultobj = SWIG_From_int(static_cast< int >(result));
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18451 PyObject *resultobj = 0;
18452 wxEvent *arg1 = (wxEvent *) 0 ;
18453 wxObject *result = 0 ;
18454 void *argp1 = 0 ;
18455 int res1 = 0 ;
18456 PyObject *swig_obj[1] ;
18457
18458 if (!args) SWIG_fail;
18459 swig_obj[0] = args;
18460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18461 if (!SWIG_IsOK(res1)) {
18462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18463 }
18464 arg1 = reinterpret_cast< wxEvent * >(argp1);
18465 {
18466 PyThreadState* __tstate = wxPyBeginAllowThreads();
18467 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 {
18472 resultobj = wxPyMake_wxObject(result, (bool)0);
18473 }
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj = 0;
18482 wxEvent *arg1 = (wxEvent *) 0 ;
18483 wxObject *arg2 = (wxObject *) 0 ;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 void *argp2 = 0 ;
18487 int res2 = 0 ;
18488 PyObject * obj0 = 0 ;
18489 PyObject * obj1 = 0 ;
18490 char * kwnames[] = {
18491 (char *) "self",(char *) "obj", NULL
18492 };
18493
18494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18496 if (!SWIG_IsOK(res1)) {
18497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18498 }
18499 arg1 = reinterpret_cast< wxEvent * >(argp1);
18500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18501 if (!SWIG_IsOK(res2)) {
18502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18503 }
18504 arg2 = reinterpret_cast< wxObject * >(argp2);
18505 {
18506 PyThreadState* __tstate = wxPyBeginAllowThreads();
18507 (arg1)->SetEventObject(arg2);
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 resultobj = SWIG_Py_Void();
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18519 PyObject *resultobj = 0;
18520 wxEvent *arg1 = (wxEvent *) 0 ;
18521 long result;
18522 void *argp1 = 0 ;
18523 int res1 = 0 ;
18524 PyObject *swig_obj[1] ;
18525
18526 if (!args) SWIG_fail;
18527 swig_obj[0] = args;
18528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18529 if (!SWIG_IsOK(res1)) {
18530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18531 }
18532 arg1 = reinterpret_cast< wxEvent * >(argp1);
18533 {
18534 PyThreadState* __tstate = wxPyBeginAllowThreads();
18535 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 resultobj = SWIG_From_long(static_cast< long >(result));
18540 return resultobj;
18541 fail:
18542 return NULL;
18543 }
18544
18545
18546 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18547 PyObject *resultobj = 0;
18548 wxEvent *arg1 = (wxEvent *) 0 ;
18549 long arg2 = (long) 0 ;
18550 void *argp1 = 0 ;
18551 int res1 = 0 ;
18552 long val2 ;
18553 int ecode2 = 0 ;
18554 PyObject * obj0 = 0 ;
18555 PyObject * obj1 = 0 ;
18556 char * kwnames[] = {
18557 (char *) "self",(char *) "ts", NULL
18558 };
18559
18560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18564 }
18565 arg1 = reinterpret_cast< wxEvent * >(argp1);
18566 if (obj1) {
18567 ecode2 = SWIG_AsVal_long(obj1, &val2);
18568 if (!SWIG_IsOK(ecode2)) {
18569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18570 }
18571 arg2 = static_cast< long >(val2);
18572 }
18573 {
18574 PyThreadState* __tstate = wxPyBeginAllowThreads();
18575 (arg1)->SetTimestamp(arg2);
18576 wxPyEndAllowThreads(__tstate);
18577 if (PyErr_Occurred()) SWIG_fail;
18578 }
18579 resultobj = SWIG_Py_Void();
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18587 PyObject *resultobj = 0;
18588 wxEvent *arg1 = (wxEvent *) 0 ;
18589 int result;
18590 void *argp1 = 0 ;
18591 int res1 = 0 ;
18592 PyObject *swig_obj[1] ;
18593
18594 if (!args) SWIG_fail;
18595 swig_obj[0] = args;
18596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18597 if (!SWIG_IsOK(res1)) {
18598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18599 }
18600 arg1 = reinterpret_cast< wxEvent * >(argp1);
18601 {
18602 PyThreadState* __tstate = wxPyBeginAllowThreads();
18603 result = (int)((wxEvent const *)arg1)->GetId();
18604 wxPyEndAllowThreads(__tstate);
18605 if (PyErr_Occurred()) SWIG_fail;
18606 }
18607 resultobj = SWIG_From_int(static_cast< int >(result));
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj = 0;
18616 wxEvent *arg1 = (wxEvent *) 0 ;
18617 int arg2 ;
18618 void *argp1 = 0 ;
18619 int res1 = 0 ;
18620 int val2 ;
18621 int ecode2 = 0 ;
18622 PyObject * obj0 = 0 ;
18623 PyObject * obj1 = 0 ;
18624 char * kwnames[] = {
18625 (char *) "self",(char *) "Id", NULL
18626 };
18627
18628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18630 if (!SWIG_IsOK(res1)) {
18631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18632 }
18633 arg1 = reinterpret_cast< wxEvent * >(argp1);
18634 ecode2 = SWIG_AsVal_int(obj1, &val2);
18635 if (!SWIG_IsOK(ecode2)) {
18636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18637 }
18638 arg2 = static_cast< int >(val2);
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 (arg1)->SetId(arg2);
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 resultobj = SWIG_Py_Void();
18646 return resultobj;
18647 fail:
18648 return NULL;
18649 }
18650
18651
18652 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18653 PyObject *resultobj = 0;
18654 wxEvent *arg1 = (wxEvent *) 0 ;
18655 bool result;
18656 void *argp1 = 0 ;
18657 int res1 = 0 ;
18658 PyObject *swig_obj[1] ;
18659
18660 if (!args) SWIG_fail;
18661 swig_obj[0] = args;
18662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18663 if (!SWIG_IsOK(res1)) {
18664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18665 }
18666 arg1 = reinterpret_cast< wxEvent * >(argp1);
18667 {
18668 PyThreadState* __tstate = wxPyBeginAllowThreads();
18669 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18670 wxPyEndAllowThreads(__tstate);
18671 if (PyErr_Occurred()) SWIG_fail;
18672 }
18673 {
18674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18675 }
18676 return resultobj;
18677 fail:
18678 return NULL;
18679 }
18680
18681
18682 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18683 PyObject *resultobj = 0;
18684 wxEvent *arg1 = (wxEvent *) 0 ;
18685 bool arg2 = (bool) true ;
18686 void *argp1 = 0 ;
18687 int res1 = 0 ;
18688 bool val2 ;
18689 int ecode2 = 0 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 char * kwnames[] = {
18693 (char *) "self",(char *) "skip", NULL
18694 };
18695
18696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18698 if (!SWIG_IsOK(res1)) {
18699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18700 }
18701 arg1 = reinterpret_cast< wxEvent * >(argp1);
18702 if (obj1) {
18703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18704 if (!SWIG_IsOK(ecode2)) {
18705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18706 }
18707 arg2 = static_cast< bool >(val2);
18708 }
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 (arg1)->Skip(arg2);
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 resultobj = SWIG_Py_Void();
18716 return resultobj;
18717 fail:
18718 return NULL;
18719 }
18720
18721
18722 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18723 PyObject *resultobj = 0;
18724 wxEvent *arg1 = (wxEvent *) 0 ;
18725 bool result;
18726 void *argp1 = 0 ;
18727 int res1 = 0 ;
18728 PyObject *swig_obj[1] ;
18729
18730 if (!args) SWIG_fail;
18731 swig_obj[0] = args;
18732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18733 if (!SWIG_IsOK(res1)) {
18734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18735 }
18736 arg1 = reinterpret_cast< wxEvent * >(argp1);
18737 {
18738 PyThreadState* __tstate = wxPyBeginAllowThreads();
18739 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18740 wxPyEndAllowThreads(__tstate);
18741 if (PyErr_Occurred()) SWIG_fail;
18742 }
18743 {
18744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18745 }
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18753 PyObject *resultobj = 0;
18754 wxEvent *arg1 = (wxEvent *) 0 ;
18755 bool result;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 PyObject *swig_obj[1] ;
18759
18760 if (!args) SWIG_fail;
18761 swig_obj[0] = args;
18762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18763 if (!SWIG_IsOK(res1)) {
18764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18765 }
18766 arg1 = reinterpret_cast< wxEvent * >(argp1);
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18770 wxPyEndAllowThreads(__tstate);
18771 if (PyErr_Occurred()) SWIG_fail;
18772 }
18773 {
18774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18783 PyObject *resultobj = 0;
18784 wxEvent *arg1 = (wxEvent *) 0 ;
18785 int result;
18786 void *argp1 = 0 ;
18787 int res1 = 0 ;
18788 PyObject *swig_obj[1] ;
18789
18790 if (!args) SWIG_fail;
18791 swig_obj[0] = args;
18792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18793 if (!SWIG_IsOK(res1)) {
18794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18795 }
18796 arg1 = reinterpret_cast< wxEvent * >(argp1);
18797 {
18798 PyThreadState* __tstate = wxPyBeginAllowThreads();
18799 result = (int)(arg1)->StopPropagation();
18800 wxPyEndAllowThreads(__tstate);
18801 if (PyErr_Occurred()) SWIG_fail;
18802 }
18803 resultobj = SWIG_From_int(static_cast< int >(result));
18804 return resultobj;
18805 fail:
18806 return NULL;
18807 }
18808
18809
18810 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18811 PyObject *resultobj = 0;
18812 wxEvent *arg1 = (wxEvent *) 0 ;
18813 int arg2 ;
18814 void *argp1 = 0 ;
18815 int res1 = 0 ;
18816 int val2 ;
18817 int ecode2 = 0 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char * kwnames[] = {
18821 (char *) "self",(char *) "propagationLevel", NULL
18822 };
18823
18824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18828 }
18829 arg1 = reinterpret_cast< wxEvent * >(argp1);
18830 ecode2 = SWIG_AsVal_int(obj1, &val2);
18831 if (!SWIG_IsOK(ecode2)) {
18832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18833 }
18834 arg2 = static_cast< int >(val2);
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 (arg1)->ResumePropagation(arg2);
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 resultobj = SWIG_Py_Void();
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 PyObject *resultobj = 0;
18850 wxEvent *arg1 = (wxEvent *) 0 ;
18851 wxEvent *result = 0 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 PyObject *swig_obj[1] ;
18855
18856 if (!args) SWIG_fail;
18857 swig_obj[0] = args;
18858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18861 }
18862 arg1 = reinterpret_cast< wxEvent * >(argp1);
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 result = (wxEvent *)(arg1)->Clone();
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18877 PyObject *obj;
18878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18879 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18880 return SWIG_Py_Void();
18881 }
18882
18883 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj = 0;
18885 wxEvent *arg1 = 0 ;
18886 wxPropagationDisabler *result = 0 ;
18887 void *argp1 = 0 ;
18888 int res1 = 0 ;
18889 PyObject * obj0 = 0 ;
18890 char * kwnames[] = {
18891 (char *) "event", NULL
18892 };
18893
18894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18895 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18896 if (!SWIG_IsOK(res1)) {
18897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18898 }
18899 if (!argp1) {
18900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18901 }
18902 arg1 = reinterpret_cast< wxEvent * >(argp1);
18903 {
18904 PyThreadState* __tstate = wxPyBeginAllowThreads();
18905 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18906 wxPyEndAllowThreads(__tstate);
18907 if (PyErr_Occurred()) SWIG_fail;
18908 }
18909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18910 return resultobj;
18911 fail:
18912 return NULL;
18913 }
18914
18915
18916 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18917 PyObject *resultobj = 0;
18918 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18919 void *argp1 = 0 ;
18920 int res1 = 0 ;
18921 PyObject *swig_obj[1] ;
18922
18923 if (!args) SWIG_fail;
18924 swig_obj[0] = args;
18925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18926 if (!SWIG_IsOK(res1)) {
18927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18928 }
18929 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 delete arg1;
18933
18934 wxPyEndAllowThreads(__tstate);
18935 if (PyErr_Occurred()) SWIG_fail;
18936 }
18937 resultobj = SWIG_Py_Void();
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18945 PyObject *obj;
18946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18947 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18948 return SWIG_Py_Void();
18949 }
18950
18951 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18952 return SWIG_Python_InitShadowInstance(args);
18953 }
18954
18955 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18956 PyObject *resultobj = 0;
18957 wxEvent *arg1 = 0 ;
18958 wxPropagateOnce *result = 0 ;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 PyObject * obj0 = 0 ;
18962 char * kwnames[] = {
18963 (char *) "event", NULL
18964 };
18965
18966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18967 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18968 if (!SWIG_IsOK(res1)) {
18969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18970 }
18971 if (!argp1) {
18972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18973 }
18974 arg1 = reinterpret_cast< wxEvent * >(argp1);
18975 {
18976 PyThreadState* __tstate = wxPyBeginAllowThreads();
18977 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18978 wxPyEndAllowThreads(__tstate);
18979 if (PyErr_Occurred()) SWIG_fail;
18980 }
18981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18989 PyObject *resultobj = 0;
18990 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18991 void *argp1 = 0 ;
18992 int res1 = 0 ;
18993 PyObject *swig_obj[1] ;
18994
18995 if (!args) SWIG_fail;
18996 swig_obj[0] = args;
18997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19000 }
19001 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 delete arg1;
19005
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 resultobj = SWIG_Py_Void();
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19017 PyObject *obj;
19018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19019 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19020 return SWIG_Py_Void();
19021 }
19022
19023 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19024 return SWIG_Python_InitShadowInstance(args);
19025 }
19026
19027 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19028 PyObject *resultobj = 0;
19029 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19030 int arg2 = (int) 0 ;
19031 wxCommandEvent *result = 0 ;
19032 int val1 ;
19033 int ecode1 = 0 ;
19034 int val2 ;
19035 int ecode2 = 0 ;
19036 PyObject * obj0 = 0 ;
19037 PyObject * obj1 = 0 ;
19038 char * kwnames[] = {
19039 (char *) "commandType",(char *) "winid", NULL
19040 };
19041
19042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19043 if (obj0) {
19044 ecode1 = SWIG_AsVal_int(obj0, &val1);
19045 if (!SWIG_IsOK(ecode1)) {
19046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19047 }
19048 arg1 = static_cast< wxEventType >(val1);
19049 }
19050 if (obj1) {
19051 ecode2 = SWIG_AsVal_int(obj1, &val2);
19052 if (!SWIG_IsOK(ecode2)) {
19053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19054 }
19055 arg2 = static_cast< int >(val2);
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19071 PyObject *resultobj = 0;
19072 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19073 int result;
19074 void *argp1 = 0 ;
19075 int res1 = 0 ;
19076 PyObject *swig_obj[1] ;
19077
19078 if (!args) SWIG_fail;
19079 swig_obj[0] = args;
19080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19081 if (!SWIG_IsOK(res1)) {
19082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19083 }
19084 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19085 {
19086 PyThreadState* __tstate = wxPyBeginAllowThreads();
19087 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19088 wxPyEndAllowThreads(__tstate);
19089 if (PyErr_Occurred()) SWIG_fail;
19090 }
19091 resultobj = SWIG_From_int(static_cast< int >(result));
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19101 wxString *arg2 = 0 ;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 bool temp2 = false ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "s", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19115 }
19116 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19117 {
19118 arg2 = wxString_in_helper(obj1);
19119 if (arg2 == NULL) SWIG_fail;
19120 temp2 = true;
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->SetString((wxString const &)*arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_Py_Void();
19129 {
19130 if (temp2)
19131 delete arg2;
19132 }
19133 return resultobj;
19134 fail:
19135 {
19136 if (temp2)
19137 delete arg2;
19138 }
19139 return NULL;
19140 }
19141
19142
19143 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19144 PyObject *resultobj = 0;
19145 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19146 wxString result;
19147 void *argp1 = 0 ;
19148 int res1 = 0 ;
19149 PyObject *swig_obj[1] ;
19150
19151 if (!args) SWIG_fail;
19152 swig_obj[0] = args;
19153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19154 if (!SWIG_IsOK(res1)) {
19155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19156 }
19157 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19158 {
19159 PyThreadState* __tstate = wxPyBeginAllowThreads();
19160 result = ((wxCommandEvent const *)arg1)->GetString();
19161 wxPyEndAllowThreads(__tstate);
19162 if (PyErr_Occurred()) SWIG_fail;
19163 }
19164 {
19165 #if wxUSE_UNICODE
19166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19167 #else
19168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19169 #endif
19170 }
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19178 PyObject *resultobj = 0;
19179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19180 bool result;
19181 void *argp1 = 0 ;
19182 int res1 = 0 ;
19183 PyObject *swig_obj[1] ;
19184
19185 if (!args) SWIG_fail;
19186 swig_obj[0] = args;
19187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19190 }
19191 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 {
19199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19200 }
19201 return resultobj;
19202 fail:
19203 return NULL;
19204 }
19205
19206
19207 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19208 PyObject *resultobj = 0;
19209 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19210 bool result;
19211 void *argp1 = 0 ;
19212 int res1 = 0 ;
19213 PyObject *swig_obj[1] ;
19214
19215 if (!args) SWIG_fail;
19216 swig_obj[0] = args;
19217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19218 if (!SWIG_IsOK(res1)) {
19219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19220 }
19221 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 {
19229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19230 }
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19238 PyObject *resultobj = 0;
19239 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19240 long arg2 ;
19241 void *argp1 = 0 ;
19242 int res1 = 0 ;
19243 long val2 ;
19244 int ecode2 = 0 ;
19245 PyObject * obj0 = 0 ;
19246 PyObject * obj1 = 0 ;
19247 char * kwnames[] = {
19248 (char *) "self",(char *) "extraLong", NULL
19249 };
19250
19251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19253 if (!SWIG_IsOK(res1)) {
19254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19255 }
19256 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19257 ecode2 = SWIG_AsVal_long(obj1, &val2);
19258 if (!SWIG_IsOK(ecode2)) {
19259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19260 }
19261 arg2 = static_cast< long >(val2);
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 (arg1)->SetExtraLong(arg2);
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 resultobj = SWIG_Py_Void();
19269 return resultobj;
19270 fail:
19271 return NULL;
19272 }
19273
19274
19275 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19276 PyObject *resultobj = 0;
19277 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19278 long result;
19279 void *argp1 = 0 ;
19280 int res1 = 0 ;
19281 PyObject *swig_obj[1] ;
19282
19283 if (!args) SWIG_fail;
19284 swig_obj[0] = args;
19285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19286 if (!SWIG_IsOK(res1)) {
19287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19288 }
19289 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 resultobj = SWIG_From_long(static_cast< long >(result));
19297 return resultobj;
19298 fail:
19299 return NULL;
19300 }
19301
19302
19303 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19304 PyObject *resultobj = 0;
19305 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19306 int arg2 ;
19307 void *argp1 = 0 ;
19308 int res1 = 0 ;
19309 int val2 ;
19310 int ecode2 = 0 ;
19311 PyObject * obj0 = 0 ;
19312 PyObject * obj1 = 0 ;
19313 char * kwnames[] = {
19314 (char *) "self",(char *) "i", NULL
19315 };
19316
19317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19319 if (!SWIG_IsOK(res1)) {
19320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19321 }
19322 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19323 ecode2 = SWIG_AsVal_int(obj1, &val2);
19324 if (!SWIG_IsOK(ecode2)) {
19325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19326 }
19327 arg2 = static_cast< int >(val2);
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 (arg1)->SetInt(arg2);
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 resultobj = SWIG_Py_Void();
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19342 PyObject *resultobj = 0;
19343 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19344 int result;
19345 void *argp1 = 0 ;
19346 int res1 = 0 ;
19347 PyObject *swig_obj[1] ;
19348
19349 if (!args) SWIG_fail;
19350 swig_obj[0] = args;
19351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19352 if (!SWIG_IsOK(res1)) {
19353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19354 }
19355 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 resultobj = SWIG_From_int(static_cast< int >(result));
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19370 PyObject *resultobj = 0;
19371 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19372 PyObject *result = 0 ;
19373 void *argp1 = 0 ;
19374 int res1 = 0 ;
19375 PyObject *swig_obj[1] ;
19376
19377 if (!args) SWIG_fail;
19378 swig_obj[0] = args;
19379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19380 if (!SWIG_IsOK(res1)) {
19381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19382 }
19383 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 resultobj = result;
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj = 0;
19399 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19400 PyObject *arg2 = (PyObject *) 0 ;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char * kwnames[] = {
19406 (char *) "self",(char *) "clientData", NULL
19407 };
19408
19409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19411 if (!SWIG_IsOK(res1)) {
19412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19413 }
19414 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19415 arg2 = obj1;
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 wxCommandEvent_SetClientData(arg1,arg2);
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_Py_Void();
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19430 PyObject *resultobj = 0;
19431 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19432 wxEvent *result = 0 ;
19433 void *argp1 = 0 ;
19434 int res1 = 0 ;
19435 PyObject *swig_obj[1] ;
19436
19437 if (!args) SWIG_fail;
19438 swig_obj[0] = args;
19439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19440 if (!SWIG_IsOK(res1)) {
19441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19442 }
19443 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19458 PyObject *obj;
19459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19460 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19461 return SWIG_Py_Void();
19462 }
19463
19464 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19465 return SWIG_Python_InitShadowInstance(args);
19466 }
19467
19468 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19469 PyObject *resultobj = 0;
19470 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19471 int arg2 = (int) 0 ;
19472 wxNotifyEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 PyObject * obj0 = 0 ;
19478 PyObject * obj1 = 0 ;
19479 char * kwnames[] = {
19480 (char *) "commandType",(char *) "winid", NULL
19481 };
19482
19483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19484 if (obj0) {
19485 ecode1 = SWIG_AsVal_int(obj0, &val1);
19486 if (!SWIG_IsOK(ecode1)) {
19487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19488 }
19489 arg1 = static_cast< wxEventType >(val1);
19490 }
19491 if (obj1) {
19492 ecode2 = SWIG_AsVal_int(obj1, &val2);
19493 if (!SWIG_IsOK(ecode2)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19495 }
19496 arg2 = static_cast< int >(val2);
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19512 PyObject *resultobj = 0;
19513 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 PyObject *swig_obj[1] ;
19517
19518 if (!args) SWIG_fail;
19519 swig_obj[0] = args;
19520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19521 if (!SWIG_IsOK(res1)) {
19522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19523 }
19524 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 (arg1)->Veto();
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 resultobj = SWIG_Py_Void();
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19539 PyObject *resultobj = 0;
19540 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19541 void *argp1 = 0 ;
19542 int res1 = 0 ;
19543 PyObject *swig_obj[1] ;
19544
19545 if (!args) SWIG_fail;
19546 swig_obj[0] = args;
19547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19548 if (!SWIG_IsOK(res1)) {
19549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19550 }
19551 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19552 {
19553 PyThreadState* __tstate = wxPyBeginAllowThreads();
19554 (arg1)->Allow();
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 resultobj = SWIG_Py_Void();
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19566 PyObject *resultobj = 0;
19567 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19568 bool result;
19569 void *argp1 = 0 ;
19570 int res1 = 0 ;
19571 PyObject *swig_obj[1] ;
19572
19573 if (!args) SWIG_fail;
19574 swig_obj[0] = args;
19575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19576 if (!SWIG_IsOK(res1)) {
19577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19578 }
19579 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (bool)(arg1)->IsAllowed();
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 {
19587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19588 }
19589 return resultobj;
19590 fail:
19591 return NULL;
19592 }
19593
19594
19595 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 PyObject *obj;
19597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19598 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19599 return SWIG_Py_Void();
19600 }
19601
19602 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19603 return SWIG_Python_InitShadowInstance(args);
19604 }
19605
19606 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19607 PyObject *resultobj = 0;
19608 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19609 int arg2 = (int) 0 ;
19610 int arg3 = (int) 0 ;
19611 int arg4 = (int) 0 ;
19612 wxScrollEvent *result = 0 ;
19613 int val1 ;
19614 int ecode1 = 0 ;
19615 int val2 ;
19616 int ecode2 = 0 ;
19617 int val3 ;
19618 int ecode3 = 0 ;
19619 int val4 ;
19620 int ecode4 = 0 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 PyObject * obj2 = 0 ;
19624 PyObject * obj3 = 0 ;
19625 char * kwnames[] = {
19626 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19627 };
19628
19629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19630 if (obj0) {
19631 ecode1 = SWIG_AsVal_int(obj0, &val1);
19632 if (!SWIG_IsOK(ecode1)) {
19633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19634 }
19635 arg1 = static_cast< wxEventType >(val1);
19636 }
19637 if (obj1) {
19638 ecode2 = SWIG_AsVal_int(obj1, &val2);
19639 if (!SWIG_IsOK(ecode2)) {
19640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19641 }
19642 arg2 = static_cast< int >(val2);
19643 }
19644 if (obj2) {
19645 ecode3 = SWIG_AsVal_int(obj2, &val3);
19646 if (!SWIG_IsOK(ecode3)) {
19647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19648 }
19649 arg3 = static_cast< int >(val3);
19650 }
19651 if (obj3) {
19652 ecode4 = SWIG_AsVal_int(obj3, &val4);
19653 if (!SWIG_IsOK(ecode4)) {
19654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19655 }
19656 arg4 = static_cast< int >(val4);
19657 }
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 PyObject *resultobj = 0;
19673 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19674 int result;
19675 void *argp1 = 0 ;
19676 int res1 = 0 ;
19677 PyObject *swig_obj[1] ;
19678
19679 if (!args) SWIG_fail;
19680 swig_obj[0] = args;
19681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19682 if (!SWIG_IsOK(res1)) {
19683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19684 }
19685 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_From_int(static_cast< int >(result));
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19700 PyObject *resultobj = 0;
19701 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19702 int result;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 PyObject *swig_obj[1] ;
19706
19707 if (!args) SWIG_fail;
19708 swig_obj[0] = args;
19709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19710 if (!SWIG_IsOK(res1)) {
19711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19712 }
19713 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_From_int(static_cast< int >(result));
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj = 0;
19729 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19730 int arg2 ;
19731 void *argp1 = 0 ;
19732 int res1 = 0 ;
19733 int val2 ;
19734 int ecode2 = 0 ;
19735 PyObject * obj0 = 0 ;
19736 PyObject * obj1 = 0 ;
19737 char * kwnames[] = {
19738 (char *) "self",(char *) "orient", NULL
19739 };
19740
19741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19743 if (!SWIG_IsOK(res1)) {
19744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19745 }
19746 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19747 ecode2 = SWIG_AsVal_int(obj1, &val2);
19748 if (!SWIG_IsOK(ecode2)) {
19749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19750 }
19751 arg2 = static_cast< int >(val2);
19752 {
19753 PyThreadState* __tstate = wxPyBeginAllowThreads();
19754 (arg1)->SetOrientation(arg2);
19755 wxPyEndAllowThreads(__tstate);
19756 if (PyErr_Occurred()) SWIG_fail;
19757 }
19758 resultobj = SWIG_Py_Void();
19759 return resultobj;
19760 fail:
19761 return NULL;
19762 }
19763
19764
19765 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj = 0;
19767 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19768 int arg2 ;
19769 void *argp1 = 0 ;
19770 int res1 = 0 ;
19771 int val2 ;
19772 int ecode2 = 0 ;
19773 PyObject * obj0 = 0 ;
19774 PyObject * obj1 = 0 ;
19775 char * kwnames[] = {
19776 (char *) "self",(char *) "pos", NULL
19777 };
19778
19779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19781 if (!SWIG_IsOK(res1)) {
19782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19783 }
19784 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19785 ecode2 = SWIG_AsVal_int(obj1, &val2);
19786 if (!SWIG_IsOK(ecode2)) {
19787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19788 }
19789 arg2 = static_cast< int >(val2);
19790 {
19791 PyThreadState* __tstate = wxPyBeginAllowThreads();
19792 (arg1)->SetPosition(arg2);
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 resultobj = SWIG_Py_Void();
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19804 PyObject *obj;
19805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19806 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19807 return SWIG_Py_Void();
19808 }
19809
19810 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19811 return SWIG_Python_InitShadowInstance(args);
19812 }
19813
19814 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj = 0;
19816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19817 int arg2 = (int) 0 ;
19818 int arg3 = (int) 0 ;
19819 wxScrollWinEvent *result = 0 ;
19820 int val1 ;
19821 int ecode1 = 0 ;
19822 int val2 ;
19823 int ecode2 = 0 ;
19824 int val3 ;
19825 int ecode3 = 0 ;
19826 PyObject * obj0 = 0 ;
19827 PyObject * obj1 = 0 ;
19828 PyObject * obj2 = 0 ;
19829 char * kwnames[] = {
19830 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19831 };
19832
19833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19834 if (obj0) {
19835 ecode1 = SWIG_AsVal_int(obj0, &val1);
19836 if (!SWIG_IsOK(ecode1)) {
19837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19838 }
19839 arg1 = static_cast< wxEventType >(val1);
19840 }
19841 if (obj1) {
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 }
19848 if (obj2) {
19849 ecode3 = SWIG_AsVal_int(obj2, &val3);
19850 if (!SWIG_IsOK(ecode3)) {
19851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19852 }
19853 arg3 = static_cast< int >(val3);
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 PyObject *resultobj = 0;
19870 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19871 int result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 PyObject *swig_obj[1] ;
19875
19876 if (!args) SWIG_fail;
19877 swig_obj[0] = args;
19878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19879 if (!SWIG_IsOK(res1)) {
19880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19881 }
19882 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 resultobj = SWIG_From_int(static_cast< int >(result));
19890 return resultobj;
19891 fail:
19892 return NULL;
19893 }
19894
19895
19896 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19897 PyObject *resultobj = 0;
19898 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19899 int result;
19900 void *argp1 = 0 ;
19901 int res1 = 0 ;
19902 PyObject *swig_obj[1] ;
19903
19904 if (!args) SWIG_fail;
19905 swig_obj[0] = args;
19906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19907 if (!SWIG_IsOK(res1)) {
19908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19909 }
19910 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_From_int(static_cast< int >(result));
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj = 0;
19926 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19927 int arg2 ;
19928 void *argp1 = 0 ;
19929 int res1 = 0 ;
19930 int val2 ;
19931 int ecode2 = 0 ;
19932 PyObject * obj0 = 0 ;
19933 PyObject * obj1 = 0 ;
19934 char * kwnames[] = {
19935 (char *) "self",(char *) "orient", NULL
19936 };
19937
19938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19940 if (!SWIG_IsOK(res1)) {
19941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19942 }
19943 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19944 ecode2 = SWIG_AsVal_int(obj1, &val2);
19945 if (!SWIG_IsOK(ecode2)) {
19946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19947 }
19948 arg2 = static_cast< int >(val2);
19949 {
19950 PyThreadState* __tstate = wxPyBeginAllowThreads();
19951 (arg1)->SetOrientation(arg2);
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_Py_Void();
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj = 0;
19964 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19965 int arg2 ;
19966 void *argp1 = 0 ;
19967 int res1 = 0 ;
19968 int val2 ;
19969 int ecode2 = 0 ;
19970 PyObject * obj0 = 0 ;
19971 PyObject * obj1 = 0 ;
19972 char * kwnames[] = {
19973 (char *) "self",(char *) "pos", NULL
19974 };
19975
19976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19978 if (!SWIG_IsOK(res1)) {
19979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19980 }
19981 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19982 ecode2 = SWIG_AsVal_int(obj1, &val2);
19983 if (!SWIG_IsOK(ecode2)) {
19984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19985 }
19986 arg2 = static_cast< int >(val2);
19987 {
19988 PyThreadState* __tstate = wxPyBeginAllowThreads();
19989 (arg1)->SetPosition(arg2);
19990 wxPyEndAllowThreads(__tstate);
19991 if (PyErr_Occurred()) SWIG_fail;
19992 }
19993 resultobj = SWIG_Py_Void();
19994 return resultobj;
19995 fail:
19996 return NULL;
19997 }
19998
19999
20000 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20001 PyObject *obj;
20002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20003 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20004 return SWIG_Py_Void();
20005 }
20006
20007 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20008 return SWIG_Python_InitShadowInstance(args);
20009 }
20010
20011 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20012 PyObject *resultobj = 0;
20013 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20014 wxMouseEvent *result = 0 ;
20015 int val1 ;
20016 int ecode1 = 0 ;
20017 PyObject * obj0 = 0 ;
20018 char * kwnames[] = {
20019 (char *) "mouseType", NULL
20020 };
20021
20022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20023 if (obj0) {
20024 ecode1 = SWIG_AsVal_int(obj0, &val1);
20025 if (!SWIG_IsOK(ecode1)) {
20026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20027 }
20028 arg1 = static_cast< wxEventType >(val1);
20029 }
20030 {
20031 PyThreadState* __tstate = wxPyBeginAllowThreads();
20032 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20033 wxPyEndAllowThreads(__tstate);
20034 if (PyErr_Occurred()) SWIG_fail;
20035 }
20036 {
20037 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20038 }
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20046 PyObject *resultobj = 0;
20047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20048 bool result;
20049 void *argp1 = 0 ;
20050 int res1 = 0 ;
20051 PyObject *swig_obj[1] ;
20052
20053 if (!args) SWIG_fail;
20054 swig_obj[0] = args;
20055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20056 if (!SWIG_IsOK(res1)) {
20057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20058 }
20059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 {
20067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20068 }
20069 return resultobj;
20070 fail:
20071 return NULL;
20072 }
20073
20074
20075 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20076 PyObject *resultobj = 0;
20077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20078 int arg2 = (int) wxMOUSE_BTN_ANY ;
20079 bool result;
20080 void *argp1 = 0 ;
20081 int res1 = 0 ;
20082 int val2 ;
20083 int ecode2 = 0 ;
20084 PyObject * obj0 = 0 ;
20085 PyObject * obj1 = 0 ;
20086 char * kwnames[] = {
20087 (char *) "self",(char *) "but", NULL
20088 };
20089
20090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20092 if (!SWIG_IsOK(res1)) {
20093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20094 }
20095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20096 if (obj1) {
20097 ecode2 = SWIG_AsVal_int(obj1, &val2);
20098 if (!SWIG_IsOK(ecode2)) {
20099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20100 }
20101 arg2 = static_cast< int >(val2);
20102 }
20103 {
20104 PyThreadState* __tstate = wxPyBeginAllowThreads();
20105 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20106 wxPyEndAllowThreads(__tstate);
20107 if (PyErr_Occurred()) SWIG_fail;
20108 }
20109 {
20110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20111 }
20112 return resultobj;
20113 fail:
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20119 PyObject *resultobj = 0;
20120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20121 int arg2 = (int) wxMOUSE_BTN_ANY ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 int val2 ;
20126 int ecode2 = 0 ;
20127 PyObject * obj0 = 0 ;
20128 PyObject * obj1 = 0 ;
20129 char * kwnames[] = {
20130 (char *) "self",(char *) "but", NULL
20131 };
20132
20133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20135 if (!SWIG_IsOK(res1)) {
20136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20137 }
20138 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20139 if (obj1) {
20140 ecode2 = SWIG_AsVal_int(obj1, &val2);
20141 if (!SWIG_IsOK(ecode2)) {
20142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20143 }
20144 arg2 = static_cast< int >(val2);
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 {
20153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20154 }
20155 return resultobj;
20156 fail:
20157 return NULL;
20158 }
20159
20160
20161 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20162 PyObject *resultobj = 0;
20163 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20164 int arg2 = (int) wxMOUSE_BTN_ANY ;
20165 bool result;
20166 void *argp1 = 0 ;
20167 int res1 = 0 ;
20168 int val2 ;
20169 int ecode2 = 0 ;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 char * kwnames[] = {
20173 (char *) "self",(char *) "but", NULL
20174 };
20175
20176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20178 if (!SWIG_IsOK(res1)) {
20179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20180 }
20181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20182 if (obj1) {
20183 ecode2 = SWIG_AsVal_int(obj1, &val2);
20184 if (!SWIG_IsOK(ecode2)) {
20185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20186 }
20187 arg2 = static_cast< int >(val2);
20188 }
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj = 0;
20206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20207 int arg2 ;
20208 bool result;
20209 void *argp1 = 0 ;
20210 int res1 = 0 ;
20211 int val2 ;
20212 int ecode2 = 0 ;
20213 PyObject * obj0 = 0 ;
20214 PyObject * obj1 = 0 ;
20215 char * kwnames[] = {
20216 (char *) "self",(char *) "button", NULL
20217 };
20218
20219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20221 if (!SWIG_IsOK(res1)) {
20222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20223 }
20224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20225 ecode2 = SWIG_AsVal_int(obj1, &val2);
20226 if (!SWIG_IsOK(ecode2)) {
20227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20228 }
20229 arg2 = static_cast< int >(val2);
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 {
20237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20238 }
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20246 PyObject *resultobj = 0;
20247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20248 int arg2 ;
20249 bool result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 int val2 ;
20253 int ecode2 = 0 ;
20254 PyObject * obj0 = 0 ;
20255 PyObject * obj1 = 0 ;
20256 char * kwnames[] = {
20257 (char *) "self",(char *) "but", NULL
20258 };
20259
20260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20262 if (!SWIG_IsOK(res1)) {
20263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20264 }
20265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20266 ecode2 = SWIG_AsVal_int(obj1, &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20269 }
20270 arg2 = static_cast< int >(val2);
20271 {
20272 PyThreadState* __tstate = wxPyBeginAllowThreads();
20273 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20274 wxPyEndAllowThreads(__tstate);
20275 if (PyErr_Occurred()) SWIG_fail;
20276 }
20277 {
20278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20279 }
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20287 PyObject *resultobj = 0;
20288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20289 int result;
20290 void *argp1 = 0 ;
20291 int res1 = 0 ;
20292 PyObject *swig_obj[1] ;
20293
20294 if (!args) SWIG_fail;
20295 swig_obj[0] = args;
20296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20297 if (!SWIG_IsOK(res1)) {
20298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20299 }
20300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20301 {
20302 PyThreadState* __tstate = wxPyBeginAllowThreads();
20303 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20304 wxPyEndAllowThreads(__tstate);
20305 if (PyErr_Occurred()) SWIG_fail;
20306 }
20307 resultobj = SWIG_From_int(static_cast< int >(result));
20308 return resultobj;
20309 fail:
20310 return NULL;
20311 }
20312
20313
20314 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20315 PyObject *resultobj = 0;
20316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20317 bool result;
20318 void *argp1 = 0 ;
20319 int res1 = 0 ;
20320 PyObject *swig_obj[1] ;
20321
20322 if (!args) SWIG_fail;
20323 swig_obj[0] = args;
20324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20325 if (!SWIG_IsOK(res1)) {
20326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20327 }
20328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 {
20336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20337 }
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20347 bool result;
20348 void *argp1 = 0 ;
20349 int res1 = 0 ;
20350 PyObject *swig_obj[1] ;
20351
20352 if (!args) SWIG_fail;
20353 swig_obj[0] = args;
20354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20355 if (!SWIG_IsOK(res1)) {
20356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20357 }
20358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 {
20366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20367 }
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20377 bool result;
20378 void *argp1 = 0 ;
20379 int res1 = 0 ;
20380 PyObject *swig_obj[1] ;
20381
20382 if (!args) SWIG_fail;
20383 swig_obj[0] = args;
20384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20385 if (!SWIG_IsOK(res1)) {
20386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20387 }
20388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20389 {
20390 PyThreadState* __tstate = wxPyBeginAllowThreads();
20391 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20392 wxPyEndAllowThreads(__tstate);
20393 if (PyErr_Occurred()) SWIG_fail;
20394 }
20395 {
20396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20397 }
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20405 PyObject *resultobj = 0;
20406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20407 bool result;
20408 void *argp1 = 0 ;
20409 int res1 = 0 ;
20410 PyObject *swig_obj[1] ;
20411
20412 if (!args) SWIG_fail;
20413 swig_obj[0] = args;
20414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20415 if (!SWIG_IsOK(res1)) {
20416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20417 }
20418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20419 {
20420 PyThreadState* __tstate = wxPyBeginAllowThreads();
20421 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 {
20426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *resultobj = 0;
20436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20437 bool result;
20438 void *argp1 = 0 ;
20439 int res1 = 0 ;
20440 PyObject *swig_obj[1] ;
20441
20442 if (!args) SWIG_fail;
20443 swig_obj[0] = args;
20444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20445 if (!SWIG_IsOK(res1)) {
20446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20447 }
20448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 {
20456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20457 }
20458 return resultobj;
20459 fail:
20460 return NULL;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 PyObject *swig_obj[1] ;
20471
20472 if (!args) SWIG_fail;
20473 swig_obj[0] = args;
20474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20475 if (!SWIG_IsOK(res1)) {
20476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20477 }
20478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20487 }
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20495 PyObject *resultobj = 0;
20496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20497 bool result;
20498 void *argp1 = 0 ;
20499 int res1 = 0 ;
20500 PyObject *swig_obj[1] ;
20501
20502 if (!args) SWIG_fail;
20503 swig_obj[0] = args;
20504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20505 if (!SWIG_IsOK(res1)) {
20506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20507 }
20508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 {
20516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20517 }
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20527 bool result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20537 }
20538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20555 PyObject *resultobj = 0;
20556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20557 bool result;
20558 void *argp1 = 0 ;
20559 int res1 = 0 ;
20560 PyObject *swig_obj[1] ;
20561
20562 if (!args) SWIG_fail;
20563 swig_obj[0] = args;
20564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20567 }
20568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20577 }
20578 return resultobj;
20579 fail:
20580 return NULL;
20581 }
20582
20583
20584 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20585 PyObject *resultobj = 0;
20586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20587 bool result;
20588 void *argp1 = 0 ;
20589 int res1 = 0 ;
20590 PyObject *swig_obj[1] ;
20591
20592 if (!args) SWIG_fail;
20593 swig_obj[0] = args;
20594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20595 if (!SWIG_IsOK(res1)) {
20596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20597 }
20598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 {
20606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20607 }
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20615 PyObject *resultobj = 0;
20616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20617 bool result;
20618 void *argp1 = 0 ;
20619 int res1 = 0 ;
20620 PyObject *swig_obj[1] ;
20621
20622 if (!args) SWIG_fail;
20623 swig_obj[0] = args;
20624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20627 }
20628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *resultobj = 0;
20646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20647 bool result;
20648 void *argp1 = 0 ;
20649 int res1 = 0 ;
20650 PyObject *swig_obj[1] ;
20651
20652 if (!args) SWIG_fail;
20653 swig_obj[0] = args;
20654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20655 if (!SWIG_IsOK(res1)) {
20656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20657 }
20658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 bool result;
20678 void *argp1 = 0 ;
20679 int res1 = 0 ;
20680 PyObject *swig_obj[1] ;
20681
20682 if (!args) SWIG_fail;
20683 swig_obj[0] = args;
20684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20685 if (!SWIG_IsOK(res1)) {
20686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20687 }
20688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20689 {
20690 PyThreadState* __tstate = wxPyBeginAllowThreads();
20691 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20692 wxPyEndAllowThreads(__tstate);
20693 if (PyErr_Occurred()) SWIG_fail;
20694 }
20695 {
20696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20697 }
20698 return resultobj;
20699 fail:
20700 return NULL;
20701 }
20702
20703
20704 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20705 PyObject *resultobj = 0;
20706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20707 bool result;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 PyObject *swig_obj[1] ;
20711
20712 if (!args) SWIG_fail;
20713 swig_obj[0] = args;
20714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20717 }
20718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20727 }
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20735 PyObject *resultobj = 0;
20736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20737 bool result;
20738 void *argp1 = 0 ;
20739 int res1 = 0 ;
20740 PyObject *swig_obj[1] ;
20741
20742 if (!args) SWIG_fail;
20743 swig_obj[0] = args;
20744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20745 if (!SWIG_IsOK(res1)) {
20746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20747 }
20748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 result = (bool)(arg1)->LeftIsDown();
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 {
20756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20757 }
20758 return resultobj;
20759 fail:
20760 return NULL;
20761 }
20762
20763
20764 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20765 PyObject *resultobj = 0;
20766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20767 bool result;
20768 void *argp1 = 0 ;
20769 int res1 = 0 ;
20770 PyObject *swig_obj[1] ;
20771
20772 if (!args) SWIG_fail;
20773 swig_obj[0] = args;
20774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20775 if (!SWIG_IsOK(res1)) {
20776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20777 }
20778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20779 {
20780 PyThreadState* __tstate = wxPyBeginAllowThreads();
20781 result = (bool)(arg1)->MiddleIsDown();
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 {
20786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20787 }
20788 return resultobj;
20789 fail:
20790 return NULL;
20791 }
20792
20793
20794 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20795 PyObject *resultobj = 0;
20796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20797 bool result;
20798 void *argp1 = 0 ;
20799 int res1 = 0 ;
20800 PyObject *swig_obj[1] ;
20801
20802 if (!args) SWIG_fail;
20803 swig_obj[0] = args;
20804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20805 if (!SWIG_IsOK(res1)) {
20806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20807 }
20808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = (bool)(arg1)->RightIsDown();
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 {
20816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20817 }
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20825 PyObject *resultobj = 0;
20826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20827 bool result;
20828 void *argp1 = 0 ;
20829 int res1 = 0 ;
20830 PyObject *swig_obj[1] ;
20831
20832 if (!args) SWIG_fail;
20833 swig_obj[0] = args;
20834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20837 }
20838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20839 {
20840 PyThreadState* __tstate = wxPyBeginAllowThreads();
20841 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20857 bool result;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 PyObject *swig_obj[1] ;
20861
20862 if (!args) SWIG_fail;
20863 swig_obj[0] = args;
20864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 {
20876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20877 }
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *resultobj = 0;
20886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20887 bool result;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 PyObject *swig_obj[1] ;
20891
20892 if (!args) SWIG_fail;
20893 swig_obj[0] = args;
20894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20897 }
20898 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 {
20906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 bool result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 {
20936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20937 }
20938 return resultobj;
20939 fail:
20940 return NULL;
20941 }
20942
20943
20944 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20945 PyObject *resultobj = 0;
20946 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20947 wxPoint result;
20948 void *argp1 = 0 ;
20949 int res1 = 0 ;
20950 PyObject *swig_obj[1] ;
20951
20952 if (!args) SWIG_fail;
20953 swig_obj[0] = args;
20954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20955 if (!SWIG_IsOK(res1)) {
20956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20957 }
20958 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20959 {
20960 PyThreadState* __tstate = wxPyBeginAllowThreads();
20961 result = (arg1)->GetPosition();
20962 wxPyEndAllowThreads(__tstate);
20963 if (PyErr_Occurred()) SWIG_fail;
20964 }
20965 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20973 PyObject *resultobj = 0;
20974 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20975 long *arg2 = (long *) 0 ;
20976 long *arg3 = (long *) 0 ;
20977 void *argp1 = 0 ;
20978 int res1 = 0 ;
20979 long temp2 ;
20980 int res2 = SWIG_TMPOBJ ;
20981 long temp3 ;
20982 int res3 = SWIG_TMPOBJ ;
20983 PyObject *swig_obj[1] ;
20984
20985 arg2 = &temp2;
20986 arg3 = &temp3;
20987 if (!args) SWIG_fail;
20988 swig_obj[0] = args;
20989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20992 }
20993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 (arg1)->GetPosition(arg2,arg3);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 resultobj = SWIG_Py_Void();
21001 if (SWIG_IsTmpObj(res2)) {
21002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21003 } else {
21004 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21006 }
21007 if (SWIG_IsTmpObj(res3)) {
21008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21009 } else {
21010 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21012 }
21013 return resultobj;
21014 fail:
21015 return NULL;
21016 }
21017
21018
21019 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21020 PyObject *resultobj = 0;
21021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21022 wxDC *arg2 = 0 ;
21023 wxPoint result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 void *argp2 = 0 ;
21027 int res2 = 0 ;
21028 PyObject * obj0 = 0 ;
21029 PyObject * obj1 = 0 ;
21030 char * kwnames[] = {
21031 (char *) "self",(char *) "dc", NULL
21032 };
21033
21034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21036 if (!SWIG_IsOK(res1)) {
21037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21038 }
21039 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21040 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21041 if (!SWIG_IsOK(res2)) {
21042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21043 }
21044 if (!argp2) {
21045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21046 }
21047 arg2 = reinterpret_cast< wxDC * >(argp2);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 int result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (int)((wxMouseEvent const *)arg1)->GetX();
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 resultobj = SWIG_From_int(static_cast< int >(result));
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21090 PyObject *resultobj = 0;
21091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21092 int result;
21093 void *argp1 = 0 ;
21094 int res1 = 0 ;
21095 PyObject *swig_obj[1] ;
21096
21097 if (!args) SWIG_fail;
21098 swig_obj[0] = args;
21099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21100 if (!SWIG_IsOK(res1)) {
21101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21102 }
21103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = (int)((wxMouseEvent const *)arg1)->GetY();
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 resultobj = SWIG_From_int(static_cast< int >(result));
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21118 PyObject *resultobj = 0;
21119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21120 int result;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 PyObject *swig_obj[1] ;
21124
21125 if (!args) SWIG_fail;
21126 swig_obj[0] = args;
21127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21128 if (!SWIG_IsOK(res1)) {
21129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21130 }
21131 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = SWIG_From_int(static_cast< int >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 int result;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 PyObject *swig_obj[1] ;
21152
21153 if (!args) SWIG_fail;
21154 swig_obj[0] = args;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 resultobj = SWIG_From_int(static_cast< int >(result));
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21174 PyObject *resultobj = 0;
21175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21176 int result;
21177 void *argp1 = 0 ;
21178 int res1 = 0 ;
21179 PyObject *swig_obj[1] ;
21180
21181 if (!args) SWIG_fail;
21182 swig_obj[0] = args;
21183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21184 if (!SWIG_IsOK(res1)) {
21185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21186 }
21187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_From_int(static_cast< int >(result));
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21202 PyObject *resultobj = 0;
21203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21204 bool result;
21205 void *argp1 = 0 ;
21206 int res1 = 0 ;
21207 PyObject *swig_obj[1] ;
21208
21209 if (!args) SWIG_fail;
21210 swig_obj[0] = args;
21211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21212 if (!SWIG_IsOK(res1)) {
21213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21214 }
21215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21219 wxPyEndAllowThreads(__tstate);
21220 if (PyErr_Occurred()) SWIG_fail;
21221 }
21222 {
21223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21224 }
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21232 PyObject *resultobj = 0;
21233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21234 int arg2 ;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 int val2 ;
21238 int ecode2 = 0 ;
21239 PyObject *swig_obj[2] ;
21240
21241 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21243 if (!SWIG_IsOK(res1)) {
21244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21245 }
21246 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21247 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21248 if (!SWIG_IsOK(ecode2)) {
21249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21250 }
21251 arg2 = static_cast< int >(val2);
21252 if (arg1) (arg1)->m_x = arg2;
21253
21254 resultobj = SWIG_Py_Void();
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21262 PyObject *resultobj = 0;
21263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21264 int result;
21265 void *argp1 = 0 ;
21266 int res1 = 0 ;
21267 PyObject *swig_obj[1] ;
21268
21269 if (!args) SWIG_fail;
21270 swig_obj[0] = args;
21271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21272 if (!SWIG_IsOK(res1)) {
21273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21274 }
21275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21276 result = (int) ((arg1)->m_x);
21277 resultobj = SWIG_From_int(static_cast< int >(result));
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21285 PyObject *resultobj = 0;
21286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21287 int arg2 ;
21288 void *argp1 = 0 ;
21289 int res1 = 0 ;
21290 int val2 ;
21291 int ecode2 = 0 ;
21292 PyObject *swig_obj[2] ;
21293
21294 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21296 if (!SWIG_IsOK(res1)) {
21297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21298 }
21299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21300 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21301 if (!SWIG_IsOK(ecode2)) {
21302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21303 }
21304 arg2 = static_cast< int >(val2);
21305 if (arg1) (arg1)->m_y = arg2;
21306
21307 resultobj = SWIG_Py_Void();
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21317 int result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21327 }
21328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21329 result = (int) ((arg1)->m_y);
21330 resultobj = SWIG_From_int(static_cast< int >(result));
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21338 PyObject *resultobj = 0;
21339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21340 bool arg2 ;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 bool val2 ;
21344 int ecode2 = 0 ;
21345 PyObject *swig_obj[2] ;
21346
21347 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21351 }
21352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21353 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21354 if (!SWIG_IsOK(ecode2)) {
21355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21356 }
21357 arg2 = static_cast< bool >(val2);
21358 if (arg1) (arg1)->m_leftDown = arg2;
21359
21360 resultobj = SWIG_Py_Void();
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21368 PyObject *resultobj = 0;
21369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21370 bool result;
21371 void *argp1 = 0 ;
21372 int res1 = 0 ;
21373 PyObject *swig_obj[1] ;
21374
21375 if (!args) SWIG_fail;
21376 swig_obj[0] = args;
21377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21378 if (!SWIG_IsOK(res1)) {
21379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21380 }
21381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21382 result = (bool) ((arg1)->m_leftDown);
21383 {
21384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21385 }
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool arg2 ;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 bool val2 ;
21399 int ecode2 = 0 ;
21400 PyObject *swig_obj[2] ;
21401
21402 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21404 if (!SWIG_IsOK(res1)) {
21405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21406 }
21407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21408 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21409 if (!SWIG_IsOK(ecode2)) {
21410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21411 }
21412 arg2 = static_cast< bool >(val2);
21413 if (arg1) (arg1)->m_middleDown = arg2;
21414
21415 resultobj = SWIG_Py_Void();
21416 return resultobj;
21417 fail:
21418 return NULL;
21419 }
21420
21421
21422 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21423 PyObject *resultobj = 0;
21424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21425 bool result;
21426 void *argp1 = 0 ;
21427 int res1 = 0 ;
21428 PyObject *swig_obj[1] ;
21429
21430 if (!args) SWIG_fail;
21431 swig_obj[0] = args;
21432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21433 if (!SWIG_IsOK(res1)) {
21434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21435 }
21436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21437 result = (bool) ((arg1)->m_middleDown);
21438 {
21439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21440 }
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21450 bool arg2 ;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 bool val2 ;
21454 int ecode2 = 0 ;
21455 PyObject *swig_obj[2] ;
21456
21457 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21461 }
21462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21463 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21464 if (!SWIG_IsOK(ecode2)) {
21465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21466 }
21467 arg2 = static_cast< bool >(val2);
21468 if (arg1) (arg1)->m_rightDown = arg2;
21469
21470 resultobj = SWIG_Py_Void();
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21478 PyObject *resultobj = 0;
21479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21480 bool result;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 PyObject *swig_obj[1] ;
21484
21485 if (!args) SWIG_fail;
21486 swig_obj[0] = args;
21487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21488 if (!SWIG_IsOK(res1)) {
21489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21490 }
21491 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21492 result = (bool) ((arg1)->m_rightDown);
21493 {
21494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21495 }
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21505 bool arg2 ;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 bool val2 ;
21509 int ecode2 = 0 ;
21510 PyObject *swig_obj[2] ;
21511
21512 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21514 if (!SWIG_IsOK(res1)) {
21515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21516 }
21517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21518 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21519 if (!SWIG_IsOK(ecode2)) {
21520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21521 }
21522 arg2 = static_cast< bool >(val2);
21523 if (arg1) (arg1)->m_controlDown = arg2;
21524
21525 resultobj = SWIG_Py_Void();
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21533 PyObject *resultobj = 0;
21534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21535 bool result;
21536 void *argp1 = 0 ;
21537 int res1 = 0 ;
21538 PyObject *swig_obj[1] ;
21539
21540 if (!args) SWIG_fail;
21541 swig_obj[0] = args;
21542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21543 if (!SWIG_IsOK(res1)) {
21544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21545 }
21546 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21547 result = (bool) ((arg1)->m_controlDown);
21548 {
21549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21550 }
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 bool arg2 ;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 bool val2 ;
21564 int ecode2 = 0 ;
21565 PyObject *swig_obj[2] ;
21566
21567 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21574 if (!SWIG_IsOK(ecode2)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21576 }
21577 arg2 = static_cast< bool >(val2);
21578 if (arg1) (arg1)->m_shiftDown = arg2;
21579
21580 resultobj = SWIG_Py_Void();
21581 return resultobj;
21582 fail:
21583 return NULL;
21584 }
21585
21586
21587 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 PyObject *resultobj = 0;
21589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21590 bool result;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 PyObject *swig_obj[1] ;
21594
21595 if (!args) SWIG_fail;
21596 swig_obj[0] = args;
21597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21598 if (!SWIG_IsOK(res1)) {
21599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21600 }
21601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21602 result = (bool) ((arg1)->m_shiftDown);
21603 {
21604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21605 }
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *resultobj = 0;
21614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21615 bool arg2 ;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 bool val2 ;
21619 int ecode2 = 0 ;
21620 PyObject *swig_obj[2] ;
21621
21622 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21626 }
21627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21628 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21629 if (!SWIG_IsOK(ecode2)) {
21630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21631 }
21632 arg2 = static_cast< bool >(val2);
21633 if (arg1) (arg1)->m_altDown = arg2;
21634
21635 resultobj = SWIG_Py_Void();
21636 return resultobj;
21637 fail:
21638 return NULL;
21639 }
21640
21641
21642 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21643 PyObject *resultobj = 0;
21644 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21645 bool result;
21646 void *argp1 = 0 ;
21647 int res1 = 0 ;
21648 PyObject *swig_obj[1] ;
21649
21650 if (!args) SWIG_fail;
21651 swig_obj[0] = args;
21652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21655 }
21656 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21657 result = (bool) ((arg1)->m_altDown);
21658 {
21659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21660 }
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 PyObject *resultobj = 0;
21669 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21670 bool arg2 ;
21671 void *argp1 = 0 ;
21672 int res1 = 0 ;
21673 bool val2 ;
21674 int ecode2 = 0 ;
21675 PyObject *swig_obj[2] ;
21676
21677 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21679 if (!SWIG_IsOK(res1)) {
21680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21681 }
21682 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21683 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21684 if (!SWIG_IsOK(ecode2)) {
21685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21686 }
21687 arg2 = static_cast< bool >(val2);
21688 if (arg1) (arg1)->m_metaDown = arg2;
21689
21690 resultobj = SWIG_Py_Void();
21691 return resultobj;
21692 fail:
21693 return NULL;
21694 }
21695
21696
21697 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21698 PyObject *resultobj = 0;
21699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21700 bool result;
21701 void *argp1 = 0 ;
21702 int res1 = 0 ;
21703 PyObject *swig_obj[1] ;
21704
21705 if (!args) SWIG_fail;
21706 swig_obj[0] = args;
21707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21708 if (!SWIG_IsOK(res1)) {
21709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21710 }
21711 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21712 result = (bool) ((arg1)->m_metaDown);
21713 {
21714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21715 }
21716 return resultobj;
21717 fail:
21718 return NULL;
21719 }
21720
21721
21722 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21723 PyObject *resultobj = 0;
21724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21725 int arg2 ;
21726 void *argp1 = 0 ;
21727 int res1 = 0 ;
21728 int val2 ;
21729 int ecode2 = 0 ;
21730 PyObject *swig_obj[2] ;
21731
21732 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21734 if (!SWIG_IsOK(res1)) {
21735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21736 }
21737 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21738 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21739 if (!SWIG_IsOK(ecode2)) {
21740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21741 }
21742 arg2 = static_cast< int >(val2);
21743 if (arg1) (arg1)->m_wheelRotation = arg2;
21744
21745 resultobj = SWIG_Py_Void();
21746 return resultobj;
21747 fail:
21748 return NULL;
21749 }
21750
21751
21752 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21753 PyObject *resultobj = 0;
21754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21755 int result;
21756 void *argp1 = 0 ;
21757 int res1 = 0 ;
21758 PyObject *swig_obj[1] ;
21759
21760 if (!args) SWIG_fail;
21761 swig_obj[0] = args;
21762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21763 if (!SWIG_IsOK(res1)) {
21764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21765 }
21766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21767 result = (int) ((arg1)->m_wheelRotation);
21768 resultobj = SWIG_From_int(static_cast< int >(result));
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 PyObject *resultobj = 0;
21777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21778 int arg2 ;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 int val2 ;
21782 int ecode2 = 0 ;
21783 PyObject *swig_obj[2] ;
21784
21785 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21787 if (!SWIG_IsOK(res1)) {
21788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21789 }
21790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21791 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21792 if (!SWIG_IsOK(ecode2)) {
21793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21794 }
21795 arg2 = static_cast< int >(val2);
21796 if (arg1) (arg1)->m_wheelDelta = arg2;
21797
21798 resultobj = SWIG_Py_Void();
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *resultobj = 0;
21807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21808 int 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_wxMouseEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21818 }
21819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21820 result = (int) ((arg1)->m_wheelDelta);
21821 resultobj = SWIG_From_int(static_cast< int >(result));
21822 return resultobj;
21823 fail:
21824 return NULL;
21825 }
21826
21827
21828 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21829 PyObject *resultobj = 0;
21830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21831 int arg2 ;
21832 void *argp1 = 0 ;
21833 int res1 = 0 ;
21834 int val2 ;
21835 int ecode2 = 0 ;
21836 PyObject *swig_obj[2] ;
21837
21838 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21842 }
21843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21844 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21845 if (!SWIG_IsOK(ecode2)) {
21846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21847 }
21848 arg2 = static_cast< int >(val2);
21849 if (arg1) (arg1)->m_linesPerAction = arg2;
21850
21851 resultobj = SWIG_Py_Void();
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21859 PyObject *resultobj = 0;
21860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21861 int result;
21862 void *argp1 = 0 ;
21863 int res1 = 0 ;
21864 PyObject *swig_obj[1] ;
21865
21866 if (!args) SWIG_fail;
21867 swig_obj[0] = args;
21868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21869 if (!SWIG_IsOK(res1)) {
21870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21871 }
21872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21873 result = (int) ((arg1)->m_linesPerAction);
21874 resultobj = SWIG_From_int(static_cast< int >(result));
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21882 PyObject *obj;
21883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21884 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21885 return SWIG_Py_Void();
21886 }
21887
21888 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21889 return SWIG_Python_InitShadowInstance(args);
21890 }
21891
21892 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21893 PyObject *resultobj = 0;
21894 int arg1 = (int) 0 ;
21895 int arg2 = (int) 0 ;
21896 wxSetCursorEvent *result = 0 ;
21897 int val1 ;
21898 int ecode1 = 0 ;
21899 int val2 ;
21900 int ecode2 = 0 ;
21901 PyObject * obj0 = 0 ;
21902 PyObject * obj1 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "x",(char *) "y", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21908 if (obj0) {
21909 ecode1 = SWIG_AsVal_int(obj0, &val1);
21910 if (!SWIG_IsOK(ecode1)) {
21911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21912 }
21913 arg1 = static_cast< int >(val1);
21914 }
21915 if (obj1) {
21916 ecode2 = SWIG_AsVal_int(obj1, &val2);
21917 if (!SWIG_IsOK(ecode2)) {
21918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21919 }
21920 arg2 = static_cast< int >(val2);
21921 }
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21925 wxPyEndAllowThreads(__tstate);
21926 if (PyErr_Occurred()) SWIG_fail;
21927 }
21928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21929 return resultobj;
21930 fail:
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21936 PyObject *resultobj = 0;
21937 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21938 int result;
21939 void *argp1 = 0 ;
21940 int res1 = 0 ;
21941 PyObject *swig_obj[1] ;
21942
21943 if (!args) SWIG_fail;
21944 swig_obj[0] = args;
21945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21946 if (!SWIG_IsOK(res1)) {
21947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21948 }
21949 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 resultobj = SWIG_From_int(static_cast< int >(result));
21957 return resultobj;
21958 fail:
21959 return NULL;
21960 }
21961
21962
21963 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21964 PyObject *resultobj = 0;
21965 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21966 int result;
21967 void *argp1 = 0 ;
21968 int res1 = 0 ;
21969 PyObject *swig_obj[1] ;
21970
21971 if (!args) SWIG_fail;
21972 swig_obj[0] = args;
21973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21974 if (!SWIG_IsOK(res1)) {
21975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21976 }
21977 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 resultobj = SWIG_From_int(static_cast< int >(result));
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj = 0;
21993 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21994 wxCursor *arg2 = 0 ;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 void *argp2 = 0 ;
21998 int res2 = 0 ;
21999 PyObject * obj0 = 0 ;
22000 PyObject * obj1 = 0 ;
22001 char * kwnames[] = {
22002 (char *) "self",(char *) "cursor", NULL
22003 };
22004
22005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22009 }
22010 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22011 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22012 if (!SWIG_IsOK(res2)) {
22013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22014 }
22015 if (!argp2) {
22016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22017 }
22018 arg2 = reinterpret_cast< wxCursor * >(argp2);
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 (arg1)->SetCursor((wxCursor const &)*arg2);
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_Py_Void();
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22035 wxCursor *result = 0 ;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 PyObject *swig_obj[1] ;
22039
22040 if (!args) SWIG_fail;
22041 swig_obj[0] = args;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22045 }
22046 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 {
22050 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22051 result = (wxCursor *) &_result_ref;
22052 }
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 {
22057 wxCursor* resultptr = new wxCursor(*result);
22058 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22079 }
22080 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22097 PyObject *obj;
22098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22099 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22100 return SWIG_Py_Void();
22101 }
22102
22103 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22104 return SWIG_Python_InitShadowInstance(args);
22105 }
22106
22107 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22108 PyObject *resultobj = 0;
22109 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22110 wxKeyEvent *result = 0 ;
22111 int val1 ;
22112 int ecode1 = 0 ;
22113 PyObject * obj0 = 0 ;
22114 char * kwnames[] = {
22115 (char *) "eventType", NULL
22116 };
22117
22118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22119 if (obj0) {
22120 ecode1 = SWIG_AsVal_int(obj0, &val1);
22121 if (!SWIG_IsOK(ecode1)) {
22122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22123 }
22124 arg1 = static_cast< wxEventType >(val1);
22125 }
22126 {
22127 PyThreadState* __tstate = wxPyBeginAllowThreads();
22128 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22140 PyObject *resultobj = 0;
22141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22142 int result;
22143 void *argp1 = 0 ;
22144 int res1 = 0 ;
22145 PyObject *swig_obj[1] ;
22146
22147 if (!args) SWIG_fail;
22148 swig_obj[0] = args;
22149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22150 if (!SWIG_IsOK(res1)) {
22151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22152 }
22153 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22154 {
22155 PyThreadState* __tstate = wxPyBeginAllowThreads();
22156 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 resultobj = SWIG_From_int(static_cast< int >(result));
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22168 PyObject *resultobj = 0;
22169 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22170 bool result;
22171 void *argp1 = 0 ;
22172 int res1 = 0 ;
22173 PyObject *swig_obj[1] ;
22174
22175 if (!args) SWIG_fail;
22176 swig_obj[0] = args;
22177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22178 if (!SWIG_IsOK(res1)) {
22179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22180 }
22181 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 {
22189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22190 }
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22198 PyObject *resultobj = 0;
22199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22200 bool result;
22201 void *argp1 = 0 ;
22202 int res1 = 0 ;
22203 PyObject *swig_obj[1] ;
22204
22205 if (!args) SWIG_fail;
22206 swig_obj[0] = args;
22207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22210 }
22211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 {
22219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22220 }
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22228 PyObject *resultobj = 0;
22229 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22230 bool result;
22231 void *argp1 = 0 ;
22232 int res1 = 0 ;
22233 PyObject *swig_obj[1] ;
22234
22235 if (!args) SWIG_fail;
22236 swig_obj[0] = args;
22237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22238 if (!SWIG_IsOK(res1)) {
22239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22240 }
22241 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 {
22249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22250 }
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22258 PyObject *resultobj = 0;
22259 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22260 bool result;
22261 void *argp1 = 0 ;
22262 int res1 = 0 ;
22263 PyObject *swig_obj[1] ;
22264
22265 if (!args) SWIG_fail;
22266 swig_obj[0] = args;
22267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22268 if (!SWIG_IsOK(res1)) {
22269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22270 }
22271 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22272 {
22273 PyThreadState* __tstate = wxPyBeginAllowThreads();
22274 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22275 wxPyEndAllowThreads(__tstate);
22276 if (PyErr_Occurred()) SWIG_fail;
22277 }
22278 {
22279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22280 }
22281 return resultobj;
22282 fail:
22283 return NULL;
22284 }
22285
22286
22287 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22288 PyObject *resultobj = 0;
22289 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22290 bool result;
22291 void *argp1 = 0 ;
22292 int res1 = 0 ;
22293 PyObject *swig_obj[1] ;
22294
22295 if (!args) SWIG_fail;
22296 swig_obj[0] = args;
22297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22298 if (!SWIG_IsOK(res1)) {
22299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22300 }
22301 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22305 wxPyEndAllowThreads(__tstate);
22306 if (PyErr_Occurred()) SWIG_fail;
22307 }
22308 {
22309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22310 }
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22318 PyObject *resultobj = 0;
22319 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22320 bool result;
22321 void *argp1 = 0 ;
22322 int res1 = 0 ;
22323 PyObject *swig_obj[1] ;
22324
22325 if (!args) SWIG_fail;
22326 swig_obj[0] = args;
22327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22328 if (!SWIG_IsOK(res1)) {
22329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22330 }
22331 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22335 wxPyEndAllowThreads(__tstate);
22336 if (PyErr_Occurred()) SWIG_fail;
22337 }
22338 {
22339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22340 }
22341 return resultobj;
22342 fail:
22343 return NULL;
22344 }
22345
22346
22347 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22348 PyObject *resultobj = 0;
22349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22350 int result;
22351 void *argp1 = 0 ;
22352 int res1 = 0 ;
22353 PyObject *swig_obj[1] ;
22354
22355 if (!args) SWIG_fail;
22356 swig_obj[0] = args;
22357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22358 if (!SWIG_IsOK(res1)) {
22359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22360 }
22361 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22362 {
22363 PyThreadState* __tstate = wxPyBeginAllowThreads();
22364 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 resultobj = SWIG_From_int(static_cast< int >(result));
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *resultobj = 0;
22377 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22378 int result;
22379 void *argp1 = 0 ;
22380 int res1 = 0 ;
22381 PyObject *swig_obj[1] ;
22382
22383 if (!args) SWIG_fail;
22384 swig_obj[0] = args;
22385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22386 if (!SWIG_IsOK(res1)) {
22387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22388 }
22389 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 resultobj = SWIG_From_int(static_cast< int >(result));
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj = 0;
22405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22406 int arg2 ;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 int val2 ;
22410 int ecode2 = 0 ;
22411 PyObject * obj0 = 0 ;
22412 PyObject * obj1 = 0 ;
22413 char * kwnames[] = {
22414 (char *) "self",(char *) "uniChar", NULL
22415 };
22416
22417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22421 }
22422 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22423 ecode2 = SWIG_AsVal_int(obj1, &val2);
22424 if (!SWIG_IsOK(ecode2)) {
22425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22426 }
22427 arg2 = static_cast< int >(val2);
22428 {
22429 PyThreadState* __tstate = wxPyBeginAllowThreads();
22430 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 resultobj = SWIG_Py_Void();
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22442 PyObject *resultobj = 0;
22443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22444 unsigned int result;
22445 void *argp1 = 0 ;
22446 int res1 = 0 ;
22447 PyObject *swig_obj[1] ;
22448
22449 if (!args) SWIG_fail;
22450 swig_obj[0] = args;
22451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22454 }
22455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22456 {
22457 PyThreadState* __tstate = wxPyBeginAllowThreads();
22458 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22470 PyObject *resultobj = 0;
22471 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22472 unsigned int result;
22473 void *argp1 = 0 ;
22474 int res1 = 0 ;
22475 PyObject *swig_obj[1] ;
22476
22477 if (!args) SWIG_fail;
22478 swig_obj[0] = args;
22479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22480 if (!SWIG_IsOK(res1)) {
22481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22482 }
22483 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 wxPoint result;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 PyObject *swig_obj[1] ;
22504
22505 if (!args) SWIG_fail;
22506 swig_obj[0] = args;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22510 }
22511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 result = (arg1)->GetPosition();
22515 wxPyEndAllowThreads(__tstate);
22516 if (PyErr_Occurred()) SWIG_fail;
22517 }
22518 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *resultobj = 0;
22527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22528 long *arg2 = (long *) 0 ;
22529 long *arg3 = (long *) 0 ;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 long temp2 ;
22533 int res2 = SWIG_TMPOBJ ;
22534 long temp3 ;
22535 int res3 = SWIG_TMPOBJ ;
22536 PyObject *swig_obj[1] ;
22537
22538 arg2 = &temp2;
22539 arg3 = &temp3;
22540 if (!args) SWIG_fail;
22541 swig_obj[0] = args;
22542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22543 if (!SWIG_IsOK(res1)) {
22544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22545 }
22546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 (arg1)->GetPosition(arg2,arg3);
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_Py_Void();
22554 if (SWIG_IsTmpObj(res2)) {
22555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22556 } else {
22557 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22559 }
22560 if (SWIG_IsTmpObj(res3)) {
22561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22562 } else {
22563 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22565 }
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22573 PyObject *resultobj = 0;
22574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22575 int result;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 PyObject *swig_obj[1] ;
22579
22580 if (!args) SWIG_fail;
22581 swig_obj[0] = args;
22582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22583 if (!SWIG_IsOK(res1)) {
22584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22585 }
22586 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 result = (int)((wxKeyEvent const *)arg1)->GetX();
22590 wxPyEndAllowThreads(__tstate);
22591 if (PyErr_Occurred()) SWIG_fail;
22592 }
22593 resultobj = SWIG_From_int(static_cast< int >(result));
22594 return resultobj;
22595 fail:
22596 return NULL;
22597 }
22598
22599
22600 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22601 PyObject *resultobj = 0;
22602 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22603 int result;
22604 void *argp1 = 0 ;
22605 int res1 = 0 ;
22606 PyObject *swig_obj[1] ;
22607
22608 if (!args) SWIG_fail;
22609 swig_obj[0] = args;
22610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22611 if (!SWIG_IsOK(res1)) {
22612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22613 }
22614 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22615 {
22616 PyThreadState* __tstate = wxPyBeginAllowThreads();
22617 result = (int)((wxKeyEvent const *)arg1)->GetY();
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 resultobj = SWIG_From_int(static_cast< int >(result));
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22629 PyObject *resultobj = 0;
22630 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22631 int arg2 ;
22632 void *argp1 = 0 ;
22633 int res1 = 0 ;
22634 int val2 ;
22635 int ecode2 = 0 ;
22636 PyObject *swig_obj[2] ;
22637
22638 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22645 if (!SWIG_IsOK(ecode2)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22647 }
22648 arg2 = static_cast< int >(val2);
22649 if (arg1) (arg1)->m_x = arg2;
22650
22651 resultobj = SWIG_Py_Void();
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22661 int result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22671 }
22672 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22673 result = (int) ((arg1)->m_x);
22674 resultobj = SWIG_From_int(static_cast< int >(result));
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22682 PyObject *resultobj = 0;
22683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22684 int arg2 ;
22685 void *argp1 = 0 ;
22686 int res1 = 0 ;
22687 int val2 ;
22688 int ecode2 = 0 ;
22689 PyObject *swig_obj[2] ;
22690
22691 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22693 if (!SWIG_IsOK(res1)) {
22694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22695 }
22696 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22697 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22698 if (!SWIG_IsOK(ecode2)) {
22699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22700 }
22701 arg2 = static_cast< int >(val2);
22702 if (arg1) (arg1)->m_y = arg2;
22703
22704 resultobj = SWIG_Py_Void();
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22712 PyObject *resultobj = 0;
22713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22714 int result;
22715 void *argp1 = 0 ;
22716 int res1 = 0 ;
22717 PyObject *swig_obj[1] ;
22718
22719 if (!args) SWIG_fail;
22720 swig_obj[0] = args;
22721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22722 if (!SWIG_IsOK(res1)) {
22723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22724 }
22725 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22726 result = (int) ((arg1)->m_y);
22727 resultobj = SWIG_From_int(static_cast< int >(result));
22728 return resultobj;
22729 fail:
22730 return NULL;
22731 }
22732
22733
22734 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22735 PyObject *resultobj = 0;
22736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22737 long arg2 ;
22738 void *argp1 = 0 ;
22739 int res1 = 0 ;
22740 long val2 ;
22741 int ecode2 = 0 ;
22742 PyObject *swig_obj[2] ;
22743
22744 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22748 }
22749 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22750 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22751 if (!SWIG_IsOK(ecode2)) {
22752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22753 }
22754 arg2 = static_cast< long >(val2);
22755 if (arg1) (arg1)->m_keyCode = arg2;
22756
22757 resultobj = SWIG_Py_Void();
22758 return resultobj;
22759 fail:
22760 return NULL;
22761 }
22762
22763
22764 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22765 PyObject *resultobj = 0;
22766 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22767 long result;
22768 void *argp1 = 0 ;
22769 int res1 = 0 ;
22770 PyObject *swig_obj[1] ;
22771
22772 if (!args) SWIG_fail;
22773 swig_obj[0] = args;
22774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22775 if (!SWIG_IsOK(res1)) {
22776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22777 }
22778 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22779 result = (long) ((arg1)->m_keyCode);
22780 resultobj = SWIG_From_long(static_cast< long >(result));
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 PyObject *resultobj = 0;
22789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22790 bool arg2 ;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 bool val2 ;
22794 int ecode2 = 0 ;
22795 PyObject *swig_obj[2] ;
22796
22797 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22801 }
22802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22803 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22804 if (!SWIG_IsOK(ecode2)) {
22805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22806 }
22807 arg2 = static_cast< bool >(val2);
22808 if (arg1) (arg1)->m_controlDown = arg2;
22809
22810 resultobj = SWIG_Py_Void();
22811 return resultobj;
22812 fail:
22813 return NULL;
22814 }
22815
22816
22817 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22818 PyObject *resultobj = 0;
22819 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22820 bool result;
22821 void *argp1 = 0 ;
22822 int res1 = 0 ;
22823 PyObject *swig_obj[1] ;
22824
22825 if (!args) SWIG_fail;
22826 swig_obj[0] = args;
22827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22828 if (!SWIG_IsOK(res1)) {
22829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22830 }
22831 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22832 result = (bool) ((arg1)->m_controlDown);
22833 {
22834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22835 }
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22843 PyObject *resultobj = 0;
22844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22845 bool arg2 ;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 bool val2 ;
22849 int ecode2 = 0 ;
22850 PyObject *swig_obj[2] ;
22851
22852 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22858 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22859 if (!SWIG_IsOK(ecode2)) {
22860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22861 }
22862 arg2 = static_cast< bool >(val2);
22863 if (arg1) (arg1)->m_shiftDown = arg2;
22864
22865 resultobj = SWIG_Py_Void();
22866 return resultobj;
22867 fail:
22868 return NULL;
22869 }
22870
22871
22872 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22873 PyObject *resultobj = 0;
22874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22875 bool result;
22876 void *argp1 = 0 ;
22877 int res1 = 0 ;
22878 PyObject *swig_obj[1] ;
22879
22880 if (!args) SWIG_fail;
22881 swig_obj[0] = args;
22882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22883 if (!SWIG_IsOK(res1)) {
22884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22885 }
22886 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22887 result = (bool) ((arg1)->m_shiftDown);
22888 {
22889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22890 }
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 bool arg2 ;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 bool val2 ;
22904 int ecode2 = 0 ;
22905 PyObject *swig_obj[2] ;
22906
22907 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22913 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22914 if (!SWIG_IsOK(ecode2)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22916 }
22917 arg2 = static_cast< bool >(val2);
22918 if (arg1) (arg1)->m_altDown = arg2;
22919
22920 resultobj = SWIG_Py_Void();
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 PyObject *resultobj = 0;
22929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22930 bool result;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 PyObject *swig_obj[1] ;
22934
22935 if (!args) SWIG_fail;
22936 swig_obj[0] = args;
22937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22938 if (!SWIG_IsOK(res1)) {
22939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22940 }
22941 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22942 result = (bool) ((arg1)->m_altDown);
22943 {
22944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22945 }
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22953 PyObject *resultobj = 0;
22954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22955 bool arg2 ;
22956 void *argp1 = 0 ;
22957 int res1 = 0 ;
22958 bool val2 ;
22959 int ecode2 = 0 ;
22960 PyObject *swig_obj[2] ;
22961
22962 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22964 if (!SWIG_IsOK(res1)) {
22965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22966 }
22967 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22968 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22969 if (!SWIG_IsOK(ecode2)) {
22970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22971 }
22972 arg2 = static_cast< bool >(val2);
22973 if (arg1) (arg1)->m_metaDown = arg2;
22974
22975 resultobj = SWIG_Py_Void();
22976 return resultobj;
22977 fail:
22978 return NULL;
22979 }
22980
22981
22982 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22983 PyObject *resultobj = 0;
22984 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22985 bool result;
22986 void *argp1 = 0 ;
22987 int res1 = 0 ;
22988 PyObject *swig_obj[1] ;
22989
22990 if (!args) SWIG_fail;
22991 swig_obj[0] = args;
22992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22993 if (!SWIG_IsOK(res1)) {
22994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22995 }
22996 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22997 result = (bool) ((arg1)->m_metaDown);
22998 {
22999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23000 }
23001 return resultobj;
23002 fail:
23003 return NULL;
23004 }
23005
23006
23007 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23008 PyObject *resultobj = 0;
23009 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23010 bool arg2 ;
23011 void *argp1 = 0 ;
23012 int res1 = 0 ;
23013 bool val2 ;
23014 int ecode2 = 0 ;
23015 PyObject *swig_obj[2] ;
23016
23017 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23019 if (!SWIG_IsOK(res1)) {
23020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23021 }
23022 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23023 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23024 if (!SWIG_IsOK(ecode2)) {
23025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23026 }
23027 arg2 = static_cast< bool >(val2);
23028 if (arg1) (arg1)->m_scanCode = arg2;
23029
23030 resultobj = SWIG_Py_Void();
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23038 PyObject *resultobj = 0;
23039 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23040 bool result;
23041 void *argp1 = 0 ;
23042 int res1 = 0 ;
23043 PyObject *swig_obj[1] ;
23044
23045 if (!args) SWIG_fail;
23046 swig_obj[0] = args;
23047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23048 if (!SWIG_IsOK(res1)) {
23049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23050 }
23051 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23052 result = (bool) ((arg1)->m_scanCode);
23053 {
23054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23055 }
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23065 unsigned int arg2 ;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 unsigned int val2 ;
23069 int ecode2 = 0 ;
23070 PyObject *swig_obj[2] ;
23071
23072 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23074 if (!SWIG_IsOK(res1)) {
23075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23076 }
23077 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23078 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23079 if (!SWIG_IsOK(ecode2)) {
23080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23081 }
23082 arg2 = static_cast< unsigned int >(val2);
23083 if (arg1) (arg1)->m_rawCode = arg2;
23084
23085 resultobj = SWIG_Py_Void();
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *resultobj = 0;
23094 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23095 unsigned int result;
23096 void *argp1 = 0 ;
23097 int res1 = 0 ;
23098 PyObject *swig_obj[1] ;
23099
23100 if (!args) SWIG_fail;
23101 swig_obj[0] = args;
23102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23103 if (!SWIG_IsOK(res1)) {
23104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23105 }
23106 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23107 result = (unsigned int) ((arg1)->m_rawCode);
23108 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23109 return resultobj;
23110 fail:
23111 return NULL;
23112 }
23113
23114
23115 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23116 PyObject *resultobj = 0;
23117 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23118 unsigned int arg2 ;
23119 void *argp1 = 0 ;
23120 int res1 = 0 ;
23121 unsigned int val2 ;
23122 int ecode2 = 0 ;
23123 PyObject *swig_obj[2] ;
23124
23125 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23127 if (!SWIG_IsOK(res1)) {
23128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23129 }
23130 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23131 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23132 if (!SWIG_IsOK(ecode2)) {
23133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23134 }
23135 arg2 = static_cast< unsigned int >(val2);
23136 if (arg1) (arg1)->m_rawFlags = arg2;
23137
23138 resultobj = SWIG_Py_Void();
23139 return resultobj;
23140 fail:
23141 return NULL;
23142 }
23143
23144
23145 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23146 PyObject *resultobj = 0;
23147 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23148 unsigned int result;
23149 void *argp1 = 0 ;
23150 int res1 = 0 ;
23151 PyObject *swig_obj[1] ;
23152
23153 if (!args) SWIG_fail;
23154 swig_obj[0] = args;
23155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23156 if (!SWIG_IsOK(res1)) {
23157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23158 }
23159 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23160 result = (unsigned int) ((arg1)->m_rawFlags);
23161 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *obj;
23170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23171 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23172 return SWIG_Py_Void();
23173 }
23174
23175 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23176 return SWIG_Python_InitShadowInstance(args);
23177 }
23178
23179 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23180 PyObject *resultobj = 0;
23181 wxSize const &arg1_defvalue = wxDefaultSize ;
23182 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23183 int arg2 = (int) 0 ;
23184 wxSizeEvent *result = 0 ;
23185 wxSize temp1 ;
23186 int val2 ;
23187 int ecode2 = 0 ;
23188 PyObject * obj0 = 0 ;
23189 PyObject * obj1 = 0 ;
23190 char * kwnames[] = {
23191 (char *) "sz",(char *) "winid", NULL
23192 };
23193
23194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23195 if (obj0) {
23196 {
23197 arg1 = &temp1;
23198 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23199 }
23200 }
23201 if (obj1) {
23202 ecode2 = SWIG_AsVal_int(obj1, &val2);
23203 if (!SWIG_IsOK(ecode2)) {
23204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23205 }
23206 arg2 = static_cast< int >(val2);
23207 }
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 PyObject *resultobj = 0;
23223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23224 wxSize result;
23225 void *argp1 = 0 ;
23226 int res1 = 0 ;
23227 PyObject *swig_obj[1] ;
23228
23229 if (!args) SWIG_fail;
23230 swig_obj[0] = args;
23231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23232 if (!SWIG_IsOK(res1)) {
23233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23234 }
23235 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 result = ((wxSizeEvent const *)arg1)->GetSize();
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23243 return resultobj;
23244 fail:
23245 return NULL;
23246 }
23247
23248
23249 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23250 PyObject *resultobj = 0;
23251 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23252 wxRect result;
23253 void *argp1 = 0 ;
23254 int res1 = 0 ;
23255 PyObject *swig_obj[1] ;
23256
23257 if (!args) SWIG_fail;
23258 swig_obj[0] = args;
23259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23260 if (!SWIG_IsOK(res1)) {
23261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23262 }
23263 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23264 {
23265 PyThreadState* __tstate = wxPyBeginAllowThreads();
23266 result = ((wxSizeEvent const *)arg1)->GetRect();
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj = 0;
23279 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23280 wxRect arg2 ;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 void *argp2 ;
23284 int res2 = 0 ;
23285 PyObject * obj0 = 0 ;
23286 PyObject * obj1 = 0 ;
23287 char * kwnames[] = {
23288 (char *) "self",(char *) "rect", NULL
23289 };
23290
23291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23293 if (!SWIG_IsOK(res1)) {
23294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23295 }
23296 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23297 {
23298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23299 if (!SWIG_IsOK(res2)) {
23300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23301 }
23302 if (!argp2) {
23303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23304 } else {
23305 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23306 arg2 = *temp;
23307 if (SWIG_IsNewObj(res2)) delete temp;
23308 }
23309 }
23310 {
23311 PyThreadState* __tstate = wxPyBeginAllowThreads();
23312 (arg1)->SetRect(arg2);
23313 wxPyEndAllowThreads(__tstate);
23314 if (PyErr_Occurred()) SWIG_fail;
23315 }
23316 resultobj = SWIG_Py_Void();
23317 return resultobj;
23318 fail:
23319 return NULL;
23320 }
23321
23322
23323 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23324 PyObject *resultobj = 0;
23325 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23326 wxSize arg2 ;
23327 void *argp1 = 0 ;
23328 int res1 = 0 ;
23329 void *argp2 ;
23330 int res2 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 PyObject * obj1 = 0 ;
23333 char * kwnames[] = {
23334 (char *) "self",(char *) "size", NULL
23335 };
23336
23337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23339 if (!SWIG_IsOK(res1)) {
23340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23341 }
23342 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23343 {
23344 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23345 if (!SWIG_IsOK(res2)) {
23346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23347 }
23348 if (!argp2) {
23349 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23350 } else {
23351 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23352 arg2 = *temp;
23353 if (SWIG_IsNewObj(res2)) delete temp;
23354 }
23355 }
23356 {
23357 PyThreadState* __tstate = wxPyBeginAllowThreads();
23358 wxSizeEvent_SetSize(arg1,arg2);
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 resultobj = SWIG_Py_Void();
23363 return resultobj;
23364 fail:
23365 return NULL;
23366 }
23367
23368
23369 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23370 PyObject *resultobj = 0;
23371 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23372 wxSize *arg2 = (wxSize *) 0 ;
23373 void *argp1 = 0 ;
23374 int res1 = 0 ;
23375 void *argp2 = 0 ;
23376 int res2 = 0 ;
23377 PyObject *swig_obj[2] ;
23378
23379 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23381 if (!SWIG_IsOK(res1)) {
23382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23383 }
23384 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23385 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23386 if (!SWIG_IsOK(res2)) {
23387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23388 }
23389 arg2 = reinterpret_cast< wxSize * >(argp2);
23390 if (arg1) (arg1)->m_size = *arg2;
23391
23392 resultobj = SWIG_Py_Void();
23393 return resultobj;
23394 fail:
23395 return NULL;
23396 }
23397
23398
23399 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23400 PyObject *resultobj = 0;
23401 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23402 wxSize *result = 0 ;
23403 void *argp1 = 0 ;
23404 int res1 = 0 ;
23405 PyObject *swig_obj[1] ;
23406
23407 if (!args) SWIG_fail;
23408 swig_obj[0] = args;
23409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23410 if (!SWIG_IsOK(res1)) {
23411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23412 }
23413 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23414 result = (wxSize *)& ((arg1)->m_size);
23415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23423 PyObject *resultobj = 0;
23424 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23425 wxRect *arg2 = (wxRect *) 0 ;
23426 void *argp1 = 0 ;
23427 int res1 = 0 ;
23428 void *argp2 = 0 ;
23429 int res2 = 0 ;
23430 PyObject *swig_obj[2] ;
23431
23432 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23434 if (!SWIG_IsOK(res1)) {
23435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23436 }
23437 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23438 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23439 if (!SWIG_IsOK(res2)) {
23440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23441 }
23442 arg2 = reinterpret_cast< wxRect * >(argp2);
23443 if (arg1) (arg1)->m_rect = *arg2;
23444
23445 resultobj = SWIG_Py_Void();
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *resultobj = 0;
23454 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23455 wxRect *result = 0 ;
23456 void *argp1 = 0 ;
23457 int res1 = 0 ;
23458 PyObject *swig_obj[1] ;
23459
23460 if (!args) SWIG_fail;
23461 swig_obj[0] = args;
23462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23463 if (!SWIG_IsOK(res1)) {
23464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23465 }
23466 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23467 result = (wxRect *)& ((arg1)->m_rect);
23468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23469 return resultobj;
23470 fail:
23471 return NULL;
23472 }
23473
23474
23475 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23476 PyObject *obj;
23477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23478 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23479 return SWIG_Py_Void();
23480 }
23481
23482 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23483 return SWIG_Python_InitShadowInstance(args);
23484 }
23485
23486 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23487 PyObject *resultobj = 0;
23488 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23489 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23490 int arg2 = (int) 0 ;
23491 wxMoveEvent *result = 0 ;
23492 wxPoint temp1 ;
23493 int val2 ;
23494 int ecode2 = 0 ;
23495 PyObject * obj0 = 0 ;
23496 PyObject * obj1 = 0 ;
23497 char * kwnames[] = {
23498 (char *) "pos",(char *) "winid", NULL
23499 };
23500
23501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23502 if (obj0) {
23503 {
23504 arg1 = &temp1;
23505 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23506 }
23507 }
23508 if (obj1) {
23509 ecode2 = SWIG_AsVal_int(obj1, &val2);
23510 if (!SWIG_IsOK(ecode2)) {
23511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23512 }
23513 arg2 = static_cast< int >(val2);
23514 }
23515 {
23516 PyThreadState* __tstate = wxPyBeginAllowThreads();
23517 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23518 wxPyEndAllowThreads(__tstate);
23519 if (PyErr_Occurred()) SWIG_fail;
23520 }
23521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 PyObject *resultobj = 0;
23530 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23531 wxPoint result;
23532 void *argp1 = 0 ;
23533 int res1 = 0 ;
23534 PyObject *swig_obj[1] ;
23535
23536 if (!args) SWIG_fail;
23537 swig_obj[0] = args;
23538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23539 if (!SWIG_IsOK(res1)) {
23540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23541 }
23542 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = ((wxMoveEvent const *)arg1)->GetPosition();
23546 wxPyEndAllowThreads(__tstate);
23547 if (PyErr_Occurred()) SWIG_fail;
23548 }
23549 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23550 return resultobj;
23551 fail:
23552 return NULL;
23553 }
23554
23555
23556 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23557 PyObject *resultobj = 0;
23558 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23559 wxRect result;
23560 void *argp1 = 0 ;
23561 int res1 = 0 ;
23562 PyObject *swig_obj[1] ;
23563
23564 if (!args) SWIG_fail;
23565 swig_obj[0] = args;
23566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23567 if (!SWIG_IsOK(res1)) {
23568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23569 }
23570 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = ((wxMoveEvent const *)arg1)->GetRect();
23574 wxPyEndAllowThreads(__tstate);
23575 if (PyErr_Occurred()) SWIG_fail;
23576 }
23577 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23585 PyObject *resultobj = 0;
23586 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23587 wxRect *arg2 = 0 ;
23588 void *argp1 = 0 ;
23589 int res1 = 0 ;
23590 wxRect temp2 ;
23591 PyObject * obj0 = 0 ;
23592 PyObject * obj1 = 0 ;
23593 char * kwnames[] = {
23594 (char *) "self",(char *) "rect", NULL
23595 };
23596
23597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23599 if (!SWIG_IsOK(res1)) {
23600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23601 }
23602 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23603 {
23604 arg2 = &temp2;
23605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23606 }
23607 {
23608 PyThreadState* __tstate = wxPyBeginAllowThreads();
23609 (arg1)->SetRect((wxRect const &)*arg2);
23610 wxPyEndAllowThreads(__tstate);
23611 if (PyErr_Occurred()) SWIG_fail;
23612 }
23613 resultobj = SWIG_Py_Void();
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23621 PyObject *resultobj = 0;
23622 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23623 wxPoint *arg2 = 0 ;
23624 void *argp1 = 0 ;
23625 int res1 = 0 ;
23626 wxPoint temp2 ;
23627 PyObject * obj0 = 0 ;
23628 PyObject * obj1 = 0 ;
23629 char * kwnames[] = {
23630 (char *) "self",(char *) "pos", NULL
23631 };
23632
23633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23635 if (!SWIG_IsOK(res1)) {
23636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23637 }
23638 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23639 {
23640 arg2 = &temp2;
23641 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23642 }
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 (arg1)->SetPosition((wxPoint const &)*arg2);
23646 wxPyEndAllowThreads(__tstate);
23647 if (PyErr_Occurred()) SWIG_fail;
23648 }
23649 resultobj = SWIG_Py_Void();
23650 return resultobj;
23651 fail:
23652 return NULL;
23653 }
23654
23655
23656 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23657 PyObject *obj;
23658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23660 return SWIG_Py_Void();
23661 }
23662
23663 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23664 return SWIG_Python_InitShadowInstance(args);
23665 }
23666
23667 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj = 0;
23669 int arg1 = (int) 0 ;
23670 wxPaintEvent *result = 0 ;
23671 int val1 ;
23672 int ecode1 = 0 ;
23673 PyObject * obj0 = 0 ;
23674 char * kwnames[] = {
23675 (char *) "Id", NULL
23676 };
23677
23678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23679 if (obj0) {
23680 ecode1 = SWIG_AsVal_int(obj0, &val1);
23681 if (!SWIG_IsOK(ecode1)) {
23682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23683 }
23684 arg1 = static_cast< int >(val1);
23685 }
23686 {
23687 PyThreadState* __tstate = wxPyBeginAllowThreads();
23688 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23689 wxPyEndAllowThreads(__tstate);
23690 if (PyErr_Occurred()) SWIG_fail;
23691 }
23692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23700 PyObject *obj;
23701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23702 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23703 return SWIG_Py_Void();
23704 }
23705
23706 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23707 return SWIG_Python_InitShadowInstance(args);
23708 }
23709
23710 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23711 PyObject *resultobj = 0;
23712 int arg1 = (int) 0 ;
23713 wxNcPaintEvent *result = 0 ;
23714 int val1 ;
23715 int ecode1 = 0 ;
23716 PyObject * obj0 = 0 ;
23717 char * kwnames[] = {
23718 (char *) "winid", NULL
23719 };
23720
23721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23722 if (obj0) {
23723 ecode1 = SWIG_AsVal_int(obj0, &val1);
23724 if (!SWIG_IsOK(ecode1)) {
23725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23726 }
23727 arg1 = static_cast< int >(val1);
23728 }
23729 {
23730 PyThreadState* __tstate = wxPyBeginAllowThreads();
23731 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23732 wxPyEndAllowThreads(__tstate);
23733 if (PyErr_Occurred()) SWIG_fail;
23734 }
23735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23743 PyObject *obj;
23744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23745 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23746 return SWIG_Py_Void();
23747 }
23748
23749 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23750 return SWIG_Python_InitShadowInstance(args);
23751 }
23752
23753 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj = 0;
23755 int arg1 = (int) 0 ;
23756 wxDC *arg2 = (wxDC *) NULL ;
23757 wxEraseEvent *result = 0 ;
23758 int val1 ;
23759 int ecode1 = 0 ;
23760 void *argp2 = 0 ;
23761 int res2 = 0 ;
23762 PyObject * obj0 = 0 ;
23763 PyObject * obj1 = 0 ;
23764 char * kwnames[] = {
23765 (char *) "Id",(char *) "dc", NULL
23766 };
23767
23768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23769 if (obj0) {
23770 ecode1 = SWIG_AsVal_int(obj0, &val1);
23771 if (!SWIG_IsOK(ecode1)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23773 }
23774 arg1 = static_cast< int >(val1);
23775 }
23776 if (obj1) {
23777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23778 if (!SWIG_IsOK(res2)) {
23779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23780 }
23781 arg2 = reinterpret_cast< wxDC * >(argp2);
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23799 wxDC *result = 0 ;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 {
23818 resultobj = wxPyMake_wxObject(result, (bool)0);
23819 }
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23827 PyObject *obj;
23828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23829 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23830 return SWIG_Py_Void();
23831 }
23832
23833 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 return SWIG_Python_InitShadowInstance(args);
23835 }
23836
23837 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj = 0;
23839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23840 int arg2 = (int) 0 ;
23841 wxFocusEvent *result = 0 ;
23842 int val1 ;
23843 int ecode1 = 0 ;
23844 int val2 ;
23845 int ecode2 = 0 ;
23846 PyObject * obj0 = 0 ;
23847 PyObject * obj1 = 0 ;
23848 char * kwnames[] = {
23849 (char *) "type",(char *) "winid", NULL
23850 };
23851
23852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23853 if (obj0) {
23854 ecode1 = SWIG_AsVal_int(obj0, &val1);
23855 if (!SWIG_IsOK(ecode1)) {
23856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23857 }
23858 arg1 = static_cast< wxEventType >(val1);
23859 }
23860 if (obj1) {
23861 ecode2 = SWIG_AsVal_int(obj1, &val2);
23862 if (!SWIG_IsOK(ecode2)) {
23863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23864 }
23865 arg2 = static_cast< int >(val2);
23866 }
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *resultobj = 0;
23882 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23883 wxWindow *result = 0 ;
23884 void *argp1 = 0 ;
23885 int res1 = 0 ;
23886 PyObject *swig_obj[1] ;
23887
23888 if (!args) SWIG_fail;
23889 swig_obj[0] = args;
23890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23893 }
23894 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23898 wxPyEndAllowThreads(__tstate);
23899 if (PyErr_Occurred()) SWIG_fail;
23900 }
23901 {
23902 resultobj = wxPyMake_wxObject(result, (bool)0);
23903 }
23904 return resultobj;
23905 fail:
23906 return NULL;
23907 }
23908
23909
23910 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23911 PyObject *resultobj = 0;
23912 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23913 wxWindow *arg2 = (wxWindow *) 0 ;
23914 void *argp1 = 0 ;
23915 int res1 = 0 ;
23916 void *argp2 = 0 ;
23917 int res2 = 0 ;
23918 PyObject * obj0 = 0 ;
23919 PyObject * obj1 = 0 ;
23920 char * kwnames[] = {
23921 (char *) "self",(char *) "win", NULL
23922 };
23923
23924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23926 if (!SWIG_IsOK(res1)) {
23927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23928 }
23929 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23931 if (!SWIG_IsOK(res2)) {
23932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23933 }
23934 arg2 = reinterpret_cast< wxWindow * >(argp2);
23935 {
23936 PyThreadState* __tstate = wxPyBeginAllowThreads();
23937 (arg1)->SetWindow(arg2);
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 resultobj = SWIG_Py_Void();
23942 return resultobj;
23943 fail:
23944 return NULL;
23945 }
23946
23947
23948 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23949 PyObject *obj;
23950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23951 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23952 return SWIG_Py_Void();
23953 }
23954
23955 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23956 return SWIG_Python_InitShadowInstance(args);
23957 }
23958
23959 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23960 PyObject *resultobj = 0;
23961 wxWindow *arg1 = (wxWindow *) NULL ;
23962 wxChildFocusEvent *result = 0 ;
23963 void *argp1 = 0 ;
23964 int res1 = 0 ;
23965 PyObject * obj0 = 0 ;
23966 char * kwnames[] = {
23967 (char *) "win", NULL
23968 };
23969
23970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23971 if (obj0) {
23972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23975 }
23976 arg1 = reinterpret_cast< wxWindow * >(argp1);
23977 }
23978 {
23979 PyThreadState* __tstate = wxPyBeginAllowThreads();
23980 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23981 wxPyEndAllowThreads(__tstate);
23982 if (PyErr_Occurred()) SWIG_fail;
23983 }
23984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23994 wxWindow *result = 0 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24004 }
24005 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 {
24013 resultobj = wxPyMake_wxObject(result, (bool)0);
24014 }
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *obj;
24023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24024 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24025 return SWIG_Py_Void();
24026 }
24027
24028 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24029 return SWIG_Python_InitShadowInstance(args);
24030 }
24031
24032 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24033 PyObject *resultobj = 0;
24034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24035 bool arg2 = (bool) true ;
24036 int arg3 = (int) 0 ;
24037 wxActivateEvent *result = 0 ;
24038 int val1 ;
24039 int ecode1 = 0 ;
24040 bool val2 ;
24041 int ecode2 = 0 ;
24042 int val3 ;
24043 int ecode3 = 0 ;
24044 PyObject * obj0 = 0 ;
24045 PyObject * obj1 = 0 ;
24046 PyObject * obj2 = 0 ;
24047 char * kwnames[] = {
24048 (char *) "type",(char *) "active",(char *) "Id", NULL
24049 };
24050
24051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24052 if (obj0) {
24053 ecode1 = SWIG_AsVal_int(obj0, &val1);
24054 if (!SWIG_IsOK(ecode1)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24056 }
24057 arg1 = static_cast< wxEventType >(val1);
24058 }
24059 if (obj1) {
24060 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24061 if (!SWIG_IsOK(ecode2)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24063 }
24064 arg2 = static_cast< bool >(val2);
24065 }
24066 if (obj2) {
24067 ecode3 = SWIG_AsVal_int(obj2, &val3);
24068 if (!SWIG_IsOK(ecode3)) {
24069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24070 }
24071 arg3 = static_cast< int >(val3);
24072 }
24073 {
24074 PyThreadState* __tstate = wxPyBeginAllowThreads();
24075 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24076 wxPyEndAllowThreads(__tstate);
24077 if (PyErr_Occurred()) SWIG_fail;
24078 }
24079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24080 return resultobj;
24081 fail:
24082 return NULL;
24083 }
24084
24085
24086 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 PyObject *resultobj = 0;
24088 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24089 bool result;
24090 void *argp1 = 0 ;
24091 int res1 = 0 ;
24092 PyObject *swig_obj[1] ;
24093
24094 if (!args) SWIG_fail;
24095 swig_obj[0] = args;
24096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24097 if (!SWIG_IsOK(res1)) {
24098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24099 }
24100 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 {
24108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24109 }
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24117 PyObject *obj;
24118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24119 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24120 return SWIG_Py_Void();
24121 }
24122
24123 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24124 return SWIG_Python_InitShadowInstance(args);
24125 }
24126
24127 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj = 0;
24129 int arg1 = (int) 0 ;
24130 wxInitDialogEvent *result = 0 ;
24131 int val1 ;
24132 int ecode1 = 0 ;
24133 PyObject * obj0 = 0 ;
24134 char * kwnames[] = {
24135 (char *) "Id", NULL
24136 };
24137
24138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24139 if (obj0) {
24140 ecode1 = SWIG_AsVal_int(obj0, &val1);
24141 if (!SWIG_IsOK(ecode1)) {
24142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24143 }
24144 arg1 = static_cast< int >(val1);
24145 }
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *obj;
24161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24162 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24163 return SWIG_Py_Void();
24164 }
24165
24166 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24167 return SWIG_Python_InitShadowInstance(args);
24168 }
24169
24170 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24171 PyObject *resultobj = 0;
24172 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24173 int arg2 = (int) 0 ;
24174 wxMenu *arg3 = (wxMenu *) NULL ;
24175 wxMenuEvent *result = 0 ;
24176 int val1 ;
24177 int ecode1 = 0 ;
24178 int val2 ;
24179 int ecode2 = 0 ;
24180 void *argp3 = 0 ;
24181 int res3 = 0 ;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 PyObject * obj2 = 0 ;
24185 char * kwnames[] = {
24186 (char *) "type",(char *) "winid",(char *) "menu", NULL
24187 };
24188
24189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24190 if (obj0) {
24191 ecode1 = SWIG_AsVal_int(obj0, &val1);
24192 if (!SWIG_IsOK(ecode1)) {
24193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24194 }
24195 arg1 = static_cast< wxEventType >(val1);
24196 }
24197 if (obj1) {
24198 ecode2 = SWIG_AsVal_int(obj1, &val2);
24199 if (!SWIG_IsOK(ecode2)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24201 }
24202 arg2 = static_cast< int >(val2);
24203 }
24204 if (obj2) {
24205 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24206 if (!SWIG_IsOK(res3)) {
24207 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24208 }
24209 arg3 = reinterpret_cast< wxMenu * >(argp3);
24210 }
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24225 PyObject *resultobj = 0;
24226 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24227 int result;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 PyObject *swig_obj[1] ;
24231
24232 if (!args) SWIG_fail;
24233 swig_obj[0] = args;
24234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24235 if (!SWIG_IsOK(res1)) {
24236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24237 }
24238 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_From_int(static_cast< int >(result));
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24253 PyObject *resultobj = 0;
24254 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24255 bool result;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 PyObject *swig_obj[1] ;
24259
24260 if (!args) SWIG_fail;
24261 swig_obj[0] = args;
24262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24265 }
24266 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 {
24274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24275 }
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *resultobj = 0;
24284 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24285 wxMenu *result = 0 ;
24286 void *argp1 = 0 ;
24287 int res1 = 0 ;
24288 PyObject *swig_obj[1] ;
24289
24290 if (!args) SWIG_fail;
24291 swig_obj[0] = args;
24292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24293 if (!SWIG_IsOK(res1)) {
24294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24295 }
24296 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = wxPyMake_wxObject(result, (bool)0);
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24313 PyObject *obj;
24314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24315 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24316 return SWIG_Py_Void();
24317 }
24318
24319 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 return SWIG_Python_InitShadowInstance(args);
24321 }
24322
24323 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24324 PyObject *resultobj = 0;
24325 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24326 int arg2 = (int) 0 ;
24327 wxCloseEvent *result = 0 ;
24328 int val1 ;
24329 int ecode1 = 0 ;
24330 int val2 ;
24331 int ecode2 = 0 ;
24332 PyObject * obj0 = 0 ;
24333 PyObject * obj1 = 0 ;
24334 char * kwnames[] = {
24335 (char *) "type",(char *) "winid", NULL
24336 };
24337
24338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24339 if (obj0) {
24340 ecode1 = SWIG_AsVal_int(obj0, &val1);
24341 if (!SWIG_IsOK(ecode1)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24343 }
24344 arg1 = static_cast< wxEventType >(val1);
24345 }
24346 if (obj1) {
24347 ecode2 = SWIG_AsVal_int(obj1, &val2);
24348 if (!SWIG_IsOK(ecode2)) {
24349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24350 }
24351 arg2 = static_cast< int >(val2);
24352 }
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24367 PyObject *resultobj = 0;
24368 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24369 bool arg2 ;
24370 void *argp1 = 0 ;
24371 int res1 = 0 ;
24372 bool val2 ;
24373 int ecode2 = 0 ;
24374 PyObject * obj0 = 0 ;
24375 PyObject * obj1 = 0 ;
24376 char * kwnames[] = {
24377 (char *) "self",(char *) "logOff", NULL
24378 };
24379
24380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24382 if (!SWIG_IsOK(res1)) {
24383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24384 }
24385 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24386 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24387 if (!SWIG_IsOK(ecode2)) {
24388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24389 }
24390 arg2 = static_cast< bool >(val2);
24391 {
24392 PyThreadState* __tstate = wxPyBeginAllowThreads();
24393 (arg1)->SetLoggingOff(arg2);
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_Py_Void();
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24407 bool result;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24417 }
24418 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 {
24426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24427 }
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj = 0;
24436 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24437 bool arg2 = (bool) true ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool val2 ;
24441 int ecode2 = 0 ;
24442 PyObject * obj0 = 0 ;
24443 PyObject * obj1 = 0 ;
24444 char * kwnames[] = {
24445 (char *) "self",(char *) "veto", NULL
24446 };
24447
24448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24450 if (!SWIG_IsOK(res1)) {
24451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24452 }
24453 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24454 if (obj1) {
24455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24456 if (!SWIG_IsOK(ecode2)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24458 }
24459 arg2 = static_cast< bool >(val2);
24460 }
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 (arg1)->Veto(arg2);
24464 wxPyEndAllowThreads(__tstate);
24465 if (PyErr_Occurred()) SWIG_fail;
24466 }
24467 resultobj = SWIG_Py_Void();
24468 return resultobj;
24469 fail:
24470 return NULL;
24471 }
24472
24473
24474 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24475 PyObject *resultobj = 0;
24476 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24477 bool result;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 PyObject *swig_obj[1] ;
24481
24482 if (!args) SWIG_fail;
24483 swig_obj[0] = args;
24484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24487 }
24488 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24489 {
24490 PyThreadState* __tstate = wxPyBeginAllowThreads();
24491 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24492 wxPyEndAllowThreads(__tstate);
24493 if (PyErr_Occurred()) SWIG_fail;
24494 }
24495 {
24496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24497 }
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24505 PyObject *resultobj = 0;
24506 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24507 bool arg2 ;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 bool val2 ;
24511 int ecode2 = 0 ;
24512 PyObject * obj0 = 0 ;
24513 PyObject * obj1 = 0 ;
24514 char * kwnames[] = {
24515 (char *) "self",(char *) "canVeto", NULL
24516 };
24517
24518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24522 }
24523 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24525 if (!SWIG_IsOK(ecode2)) {
24526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24527 }
24528 arg2 = static_cast< bool >(val2);
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 (arg1)->SetCanVeto(arg2);
24532 wxPyEndAllowThreads(__tstate);
24533 if (PyErr_Occurred()) SWIG_fail;
24534 }
24535 resultobj = SWIG_Py_Void();
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 PyObject *resultobj = 0;
24544 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24545 bool result;
24546 void *argp1 = 0 ;
24547 int res1 = 0 ;
24548 PyObject *swig_obj[1] ;
24549
24550 if (!args) SWIG_fail;
24551 swig_obj[0] = args;
24552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24553 if (!SWIG_IsOK(res1)) {
24554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24555 }
24556 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 {
24564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24565 }
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24573 PyObject *obj;
24574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24575 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24576 return SWIG_Py_Void();
24577 }
24578
24579 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24580 return SWIG_Python_InitShadowInstance(args);
24581 }
24582
24583 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24584 PyObject *resultobj = 0;
24585 int arg1 = (int) 0 ;
24586 bool arg2 = (bool) false ;
24587 wxShowEvent *result = 0 ;
24588 int val1 ;
24589 int ecode1 = 0 ;
24590 bool val2 ;
24591 int ecode2 = 0 ;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char * kwnames[] = {
24595 (char *) "winid",(char *) "show", NULL
24596 };
24597
24598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24599 if (obj0) {
24600 ecode1 = SWIG_AsVal_int(obj0, &val1);
24601 if (!SWIG_IsOK(ecode1)) {
24602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24603 }
24604 arg1 = static_cast< int >(val1);
24605 }
24606 if (obj1) {
24607 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24608 if (!SWIG_IsOK(ecode2)) {
24609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24610 }
24611 arg2 = static_cast< bool >(val2);
24612 }
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24627 PyObject *resultobj = 0;
24628 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24629 bool arg2 ;
24630 void *argp1 = 0 ;
24631 int res1 = 0 ;
24632 bool val2 ;
24633 int ecode2 = 0 ;
24634 PyObject * obj0 = 0 ;
24635 PyObject * obj1 = 0 ;
24636 char * kwnames[] = {
24637 (char *) "self",(char *) "show", NULL
24638 };
24639
24640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24642 if (!SWIG_IsOK(res1)) {
24643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24644 }
24645 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24646 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24647 if (!SWIG_IsOK(ecode2)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24649 }
24650 arg2 = static_cast< bool >(val2);
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 (arg1)->SetShow(arg2);
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 resultobj = SWIG_Py_Void();
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *resultobj = 0;
24666 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24667 bool result;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 PyObject *swig_obj[1] ;
24671
24672 if (!args) SWIG_fail;
24673 swig_obj[0] = args;
24674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24677 }
24678 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24679 {
24680 PyThreadState* __tstate = wxPyBeginAllowThreads();
24681 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 {
24686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 PyObject *obj;
24696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24697 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24698 return SWIG_Py_Void();
24699 }
24700
24701 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24702 return SWIG_Python_InitShadowInstance(args);
24703 }
24704
24705 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24706 PyObject *resultobj = 0;
24707 int arg1 = (int) 0 ;
24708 bool arg2 = (bool) true ;
24709 wxIconizeEvent *result = 0 ;
24710 int val1 ;
24711 int ecode1 = 0 ;
24712 bool val2 ;
24713 int ecode2 = 0 ;
24714 PyObject * obj0 = 0 ;
24715 PyObject * obj1 = 0 ;
24716 char * kwnames[] = {
24717 (char *) "id",(char *) "iconized", NULL
24718 };
24719
24720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24721 if (obj0) {
24722 ecode1 = SWIG_AsVal_int(obj0, &val1);
24723 if (!SWIG_IsOK(ecode1)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24725 }
24726 arg1 = static_cast< int >(val1);
24727 }
24728 if (obj1) {
24729 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24730 if (!SWIG_IsOK(ecode2)) {
24731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24732 }
24733 arg2 = static_cast< bool >(val2);
24734 }
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24751 bool result;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 PyObject *swig_obj[1] ;
24755
24756 if (!args) SWIG_fail;
24757 swig_obj[0] = args;
24758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24761 }
24762 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (bool)(arg1)->Iconized();
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 {
24770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24771 }
24772 return resultobj;
24773 fail:
24774 return NULL;
24775 }
24776
24777
24778 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24779 PyObject *obj;
24780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24781 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24782 return SWIG_Py_Void();
24783 }
24784
24785 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24786 return SWIG_Python_InitShadowInstance(args);
24787 }
24788
24789 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24790 PyObject *resultobj = 0;
24791 int arg1 = (int) 0 ;
24792 wxMaximizeEvent *result = 0 ;
24793 int val1 ;
24794 int ecode1 = 0 ;
24795 PyObject * obj0 = 0 ;
24796 char * kwnames[] = {
24797 (char *) "id", NULL
24798 };
24799
24800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24801 if (obj0) {
24802 ecode1 = SWIG_AsVal_int(obj0, &val1);
24803 if (!SWIG_IsOK(ecode1)) {
24804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24805 }
24806 arg1 = static_cast< int >(val1);
24807 }
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24815 return resultobj;
24816 fail:
24817 return NULL;
24818 }
24819
24820
24821 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24822 PyObject *obj;
24823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24824 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24825 return SWIG_Py_Void();
24826 }
24827
24828 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24829 return SWIG_Python_InitShadowInstance(args);
24830 }
24831
24832 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24833 PyObject *resultobj = 0;
24834 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24835 wxPoint result;
24836 void *argp1 = 0 ;
24837 int res1 = 0 ;
24838 PyObject *swig_obj[1] ;
24839
24840 if (!args) SWIG_fail;
24841 swig_obj[0] = args;
24842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24843 if (!SWIG_IsOK(res1)) {
24844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24845 }
24846 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24847 {
24848 PyThreadState* __tstate = wxPyBeginAllowThreads();
24849 result = (arg1)->GetPosition();
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24861 PyObject *resultobj = 0;
24862 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24863 int result;
24864 void *argp1 = 0 ;
24865 int res1 = 0 ;
24866 PyObject *swig_obj[1] ;
24867
24868 if (!args) SWIG_fail;
24869 swig_obj[0] = args;
24870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24871 if (!SWIG_IsOK(res1)) {
24872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24873 }
24874 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (int)(arg1)->GetNumberOfFiles();
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 resultobj = SWIG_From_int(static_cast< int >(result));
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24891 PyObject *result = 0 ;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24901 }
24902 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 resultobj = result;
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24917 PyObject *obj;
24918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24919 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24920 return SWIG_Py_Void();
24921 }
24922
24923 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj = 0;
24925 int arg1 = (int) 0 ;
24926 wxUpdateUIEvent *result = 0 ;
24927 int val1 ;
24928 int ecode1 = 0 ;
24929 PyObject * obj0 = 0 ;
24930 char * kwnames[] = {
24931 (char *) "commandId", NULL
24932 };
24933
24934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24935 if (obj0) {
24936 ecode1 = SWIG_AsVal_int(obj0, &val1);
24937 if (!SWIG_IsOK(ecode1)) {
24938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24939 }
24940 arg1 = static_cast< int >(val1);
24941 }
24942 {
24943 PyThreadState* __tstate = wxPyBeginAllowThreads();
24944 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24956 PyObject *resultobj = 0;
24957 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24958 bool result;
24959 void *argp1 = 0 ;
24960 int res1 = 0 ;
24961 PyObject *swig_obj[1] ;
24962
24963 if (!args) SWIG_fail;
24964 swig_obj[0] = args;
24965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24966 if (!SWIG_IsOK(res1)) {
24967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24968 }
24969 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24970 {
24971 PyThreadState* __tstate = wxPyBeginAllowThreads();
24972 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24973 wxPyEndAllowThreads(__tstate);
24974 if (PyErr_Occurred()) SWIG_fail;
24975 }
24976 {
24977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24978 }
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24986 PyObject *resultobj = 0;
24987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24988 bool result;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 PyObject *swig_obj[1] ;
24992
24993 if (!args) SWIG_fail;
24994 swig_obj[0] = args;
24995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24996 if (!SWIG_IsOK(res1)) {
24997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24998 }
24999 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 {
25007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25008 }
25009 return resultobj;
25010 fail:
25011 return NULL;
25012 }
25013
25014
25015 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25016 PyObject *resultobj = 0;
25017 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25018 bool result;
25019 void *argp1 = 0 ;
25020 int res1 = 0 ;
25021 PyObject *swig_obj[1] ;
25022
25023 if (!args) SWIG_fail;
25024 swig_obj[0] = args;
25025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25026 if (!SWIG_IsOK(res1)) {
25027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25028 }
25029 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 {
25037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25038 }
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25046 PyObject *resultobj = 0;
25047 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25048 wxString result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 PyObject *swig_obj[1] ;
25052
25053 if (!args) SWIG_fail;
25054 swig_obj[0] = args;
25055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25056 if (!SWIG_IsOK(res1)) {
25057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25058 }
25059 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 #if wxUSE_UNICODE
25068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25069 #else
25070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25071 #endif
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25082 bool result;
25083 void *argp1 = 0 ;
25084 int res1 = 0 ;
25085 PyObject *swig_obj[1] ;
25086
25087 if (!args) SWIG_fail;
25088 swig_obj[0] = args;
25089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25092 }
25093 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25110 PyObject *resultobj = 0;
25111 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25112 bool result;
25113 void *argp1 = 0 ;
25114 int res1 = 0 ;
25115 PyObject *swig_obj[1] ;
25116
25117 if (!args) SWIG_fail;
25118 swig_obj[0] = args;
25119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25120 if (!SWIG_IsOK(res1)) {
25121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25122 }
25123 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25142 bool result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 PyObject *swig_obj[1] ;
25146
25147 if (!args) SWIG_fail;
25148 swig_obj[0] = args;
25149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25170 PyObject *resultobj = 0;
25171 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25172 bool result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 PyObject *swig_obj[1] ;
25176
25177 if (!args) SWIG_fail;
25178 swig_obj[0] = args;
25179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25180 if (!SWIG_IsOK(res1)) {
25181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25182 }
25183 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 {
25191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25192 }
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj = 0;
25201 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25202 bool arg2 ;
25203 void *argp1 = 0 ;
25204 int res1 = 0 ;
25205 bool val2 ;
25206 int ecode2 = 0 ;
25207 PyObject * obj0 = 0 ;
25208 PyObject * obj1 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "self",(char *) "check", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25217 }
25218 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25219 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25220 if (!SWIG_IsOK(ecode2)) {
25221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25222 }
25223 arg2 = static_cast< bool >(val2);
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 (arg1)->Check(arg2);
25227 wxPyEndAllowThreads(__tstate);
25228 if (PyErr_Occurred()) SWIG_fail;
25229 }
25230 resultobj = SWIG_Py_Void();
25231 return resultobj;
25232 fail:
25233 return NULL;
25234 }
25235
25236
25237 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25238 PyObject *resultobj = 0;
25239 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25240 bool arg2 ;
25241 void *argp1 = 0 ;
25242 int res1 = 0 ;
25243 bool val2 ;
25244 int ecode2 = 0 ;
25245 PyObject * obj0 = 0 ;
25246 PyObject * obj1 = 0 ;
25247 char * kwnames[] = {
25248 (char *) "self",(char *) "enable", NULL
25249 };
25250
25251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25253 if (!SWIG_IsOK(res1)) {
25254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25255 }
25256 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25257 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25258 if (!SWIG_IsOK(ecode2)) {
25259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25260 }
25261 arg2 = static_cast< bool >(val2);
25262 {
25263 PyThreadState* __tstate = wxPyBeginAllowThreads();
25264 (arg1)->Enable(arg2);
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 resultobj = SWIG_Py_Void();
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25276 PyObject *resultobj = 0;
25277 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25278 bool arg2 ;
25279 void *argp1 = 0 ;
25280 int res1 = 0 ;
25281 bool val2 ;
25282 int ecode2 = 0 ;
25283 PyObject * obj0 = 0 ;
25284 PyObject * obj1 = 0 ;
25285 char * kwnames[] = {
25286 (char *) "self",(char *) "show", NULL
25287 };
25288
25289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25291 if (!SWIG_IsOK(res1)) {
25292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25293 }
25294 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25295 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25296 if (!SWIG_IsOK(ecode2)) {
25297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25298 }
25299 arg2 = static_cast< bool >(val2);
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 (arg1)->Show(arg2);
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 resultobj = SWIG_Py_Void();
25307 return resultobj;
25308 fail:
25309 return NULL;
25310 }
25311
25312
25313 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25314 PyObject *resultobj = 0;
25315 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25316 wxString *arg2 = 0 ;
25317 void *argp1 = 0 ;
25318 int res1 = 0 ;
25319 bool temp2 = false ;
25320 PyObject * obj0 = 0 ;
25321 PyObject * obj1 = 0 ;
25322 char * kwnames[] = {
25323 (char *) "self",(char *) "text", NULL
25324 };
25325
25326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25328 if (!SWIG_IsOK(res1)) {
25329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25330 }
25331 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25332 {
25333 arg2 = wxString_in_helper(obj1);
25334 if (arg2 == NULL) SWIG_fail;
25335 temp2 = true;
25336 }
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 (arg1)->SetText((wxString const &)*arg2);
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_Py_Void();
25344 {
25345 if (temp2)
25346 delete arg2;
25347 }
25348 return resultobj;
25349 fail:
25350 {
25351 if (temp2)
25352 delete arg2;
25353 }
25354 return NULL;
25355 }
25356
25357
25358 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25359 PyObject *resultobj = 0;
25360 long arg1 ;
25361 long val1 ;
25362 int ecode1 = 0 ;
25363 PyObject * obj0 = 0 ;
25364 char * kwnames[] = {
25365 (char *) "updateInterval", NULL
25366 };
25367
25368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25369 ecode1 = SWIG_AsVal_long(obj0, &val1);
25370 if (!SWIG_IsOK(ecode1)) {
25371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25372 }
25373 arg1 = static_cast< long >(val1);
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 wxUpdateUIEvent::SetUpdateInterval(arg1);
25377 wxPyEndAllowThreads(__tstate);
25378 if (PyErr_Occurred()) SWIG_fail;
25379 }
25380 resultobj = SWIG_Py_Void();
25381 return resultobj;
25382 fail:
25383 return NULL;
25384 }
25385
25386
25387 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25388 PyObject *resultobj = 0;
25389 long result;
25390
25391 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25392 {
25393 PyThreadState* __tstate = wxPyBeginAllowThreads();
25394 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25395 wxPyEndAllowThreads(__tstate);
25396 if (PyErr_Occurred()) SWIG_fail;
25397 }
25398 resultobj = SWIG_From_long(static_cast< long >(result));
25399 return resultobj;
25400 fail:
25401 return NULL;
25402 }
25403
25404
25405 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj = 0;
25407 wxWindow *arg1 = (wxWindow *) 0 ;
25408 bool result;
25409 void *argp1 = 0 ;
25410 int res1 = 0 ;
25411 PyObject * obj0 = 0 ;
25412 char * kwnames[] = {
25413 (char *) "win", NULL
25414 };
25415
25416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25418 if (!SWIG_IsOK(res1)) {
25419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25420 }
25421 arg1 = reinterpret_cast< wxWindow * >(argp1);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 {
25429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25438 PyObject *resultobj = 0;
25439
25440 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25441 {
25442 PyThreadState* __tstate = wxPyBeginAllowThreads();
25443 wxUpdateUIEvent::ResetUpdateTime();
25444 wxPyEndAllowThreads(__tstate);
25445 if (PyErr_Occurred()) SWIG_fail;
25446 }
25447 resultobj = SWIG_Py_Void();
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj = 0;
25456 wxUpdateUIMode arg1 ;
25457 int val1 ;
25458 int ecode1 = 0 ;
25459 PyObject * obj0 = 0 ;
25460 char * kwnames[] = {
25461 (char *) "mode", NULL
25462 };
25463
25464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25465 ecode1 = SWIG_AsVal_int(obj0, &val1);
25466 if (!SWIG_IsOK(ecode1)) {
25467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25468 }
25469 arg1 = static_cast< wxUpdateUIMode >(val1);
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 wxUpdateUIEvent::SetMode(arg1);
25473 wxPyEndAllowThreads(__tstate);
25474 if (PyErr_Occurred()) SWIG_fail;
25475 }
25476 resultobj = SWIG_Py_Void();
25477 return resultobj;
25478 fail:
25479 return NULL;
25480 }
25481
25482
25483 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25484 PyObject *resultobj = 0;
25485 wxUpdateUIMode result;
25486
25487 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25491 wxPyEndAllowThreads(__tstate);
25492 if (PyErr_Occurred()) SWIG_fail;
25493 }
25494 resultobj = SWIG_From_int(static_cast< int >(result));
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25502 PyObject *obj;
25503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25504 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25505 return SWIG_Py_Void();
25506 }
25507
25508 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25509 return SWIG_Python_InitShadowInstance(args);
25510 }
25511
25512 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25513 PyObject *resultobj = 0;
25514 wxSysColourChangedEvent *result = 0 ;
25515
25516 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25531 PyObject *obj;
25532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25533 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25534 return SWIG_Py_Void();
25535 }
25536
25537 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25538 return SWIG_Python_InitShadowInstance(args);
25539 }
25540
25541 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj = 0;
25543 int arg1 = (int) 0 ;
25544 wxWindow *arg2 = (wxWindow *) NULL ;
25545 wxMouseCaptureChangedEvent *result = 0 ;
25546 int val1 ;
25547 int ecode1 = 0 ;
25548 void *argp2 = 0 ;
25549 int res2 = 0 ;
25550 PyObject * obj0 = 0 ;
25551 PyObject * obj1 = 0 ;
25552 char * kwnames[] = {
25553 (char *) "winid",(char *) "gainedCapture", NULL
25554 };
25555
25556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25557 if (obj0) {
25558 ecode1 = SWIG_AsVal_int(obj0, &val1);
25559 if (!SWIG_IsOK(ecode1)) {
25560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25561 }
25562 arg1 = static_cast< int >(val1);
25563 }
25564 if (obj1) {
25565 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25566 if (!SWIG_IsOK(res2)) {
25567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25568 }
25569 arg2 = reinterpret_cast< wxWindow * >(argp2);
25570 }
25571 {
25572 PyThreadState* __tstate = wxPyBeginAllowThreads();
25573 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25585 PyObject *resultobj = 0;
25586 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25587 wxWindow *result = 0 ;
25588 void *argp1 = 0 ;
25589 int res1 = 0 ;
25590 PyObject *swig_obj[1] ;
25591
25592 if (!args) SWIG_fail;
25593 swig_obj[0] = args;
25594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25595 if (!SWIG_IsOK(res1)) {
25596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25597 }
25598 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25602 wxPyEndAllowThreads(__tstate);
25603 if (PyErr_Occurred()) SWIG_fail;
25604 }
25605 {
25606 resultobj = wxPyMake_wxObject(result, (bool)0);
25607 }
25608 return resultobj;
25609 fail:
25610 return NULL;
25611 }
25612
25613
25614 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25615 PyObject *obj;
25616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25617 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25618 return SWIG_Py_Void();
25619 }
25620
25621 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25622 return SWIG_Python_InitShadowInstance(args);
25623 }
25624
25625 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25626 PyObject *resultobj = 0;
25627 int arg1 = (int) 0 ;
25628 wxMouseCaptureLostEvent *result = 0 ;
25629 int val1 ;
25630 int ecode1 = 0 ;
25631 PyObject * obj0 = 0 ;
25632 char * kwnames[] = {
25633 (char *) "winid", NULL
25634 };
25635
25636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25637 if (obj0) {
25638 ecode1 = SWIG_AsVal_int(obj0, &val1);
25639 if (!SWIG_IsOK(ecode1)) {
25640 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25641 }
25642 arg1 = static_cast< int >(val1);
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *obj;
25659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25660 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25661 return SWIG_Py_Void();
25662 }
25663
25664 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 return SWIG_Python_InitShadowInstance(args);
25666 }
25667
25668 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25669 PyObject *resultobj = 0;
25670 wxDisplayChangedEvent *result = 0 ;
25671
25672 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25680 return resultobj;
25681 fail:
25682 return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25687 PyObject *obj;
25688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25689 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25690 return SWIG_Py_Void();
25691 }
25692
25693 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 return SWIG_Python_InitShadowInstance(args);
25695 }
25696
25697 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj = 0;
25699 int arg1 = (int) 0 ;
25700 wxPaletteChangedEvent *result = 0 ;
25701 int val1 ;
25702 int ecode1 = 0 ;
25703 PyObject * obj0 = 0 ;
25704 char * kwnames[] = {
25705 (char *) "id", NULL
25706 };
25707
25708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25709 if (obj0) {
25710 ecode1 = SWIG_AsVal_int(obj0, &val1);
25711 if (!SWIG_IsOK(ecode1)) {
25712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25713 }
25714 arg1 = static_cast< int >(val1);
25715 }
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25719 wxPyEndAllowThreads(__tstate);
25720 if (PyErr_Occurred()) SWIG_fail;
25721 }
25722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25723 return resultobj;
25724 fail:
25725 return NULL;
25726 }
25727
25728
25729 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25730 PyObject *resultobj = 0;
25731 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25732 wxWindow *arg2 = (wxWindow *) 0 ;
25733 void *argp1 = 0 ;
25734 int res1 = 0 ;
25735 void *argp2 = 0 ;
25736 int res2 = 0 ;
25737 PyObject * obj0 = 0 ;
25738 PyObject * obj1 = 0 ;
25739 char * kwnames[] = {
25740 (char *) "self",(char *) "win", NULL
25741 };
25742
25743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25745 if (!SWIG_IsOK(res1)) {
25746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25747 }
25748 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25750 if (!SWIG_IsOK(res2)) {
25751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25752 }
25753 arg2 = reinterpret_cast< wxWindow * >(argp2);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 (arg1)->SetChangedWindow(arg2);
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 resultobj = SWIG_Py_Void();
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25768 PyObject *resultobj = 0;
25769 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25770 wxWindow *result = 0 ;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 PyObject *swig_obj[1] ;
25774
25775 if (!args) SWIG_fail;
25776 swig_obj[0] = args;
25777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25780 }
25781 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25782 {
25783 PyThreadState* __tstate = wxPyBeginAllowThreads();
25784 result = (wxWindow *)(arg1)->GetChangedWindow();
25785 wxPyEndAllowThreads(__tstate);
25786 if (PyErr_Occurred()) SWIG_fail;
25787 }
25788 {
25789 resultobj = wxPyMake_wxObject(result, (bool)0);
25790 }
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *obj;
25799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25800 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25801 return SWIG_Py_Void();
25802 }
25803
25804 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 return SWIG_Python_InitShadowInstance(args);
25806 }
25807
25808 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj = 0;
25810 int arg1 = (int) 0 ;
25811 wxQueryNewPaletteEvent *result = 0 ;
25812 int val1 ;
25813 int ecode1 = 0 ;
25814 PyObject * obj0 = 0 ;
25815 char * kwnames[] = {
25816 (char *) "winid", NULL
25817 };
25818
25819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25820 if (obj0) {
25821 ecode1 = SWIG_AsVal_int(obj0, &val1);
25822 if (!SWIG_IsOK(ecode1)) {
25823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25824 }
25825 arg1 = static_cast< int >(val1);
25826 }
25827 {
25828 PyThreadState* __tstate = wxPyBeginAllowThreads();
25829 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25841 PyObject *resultobj = 0;
25842 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25843 bool arg2 ;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 bool val2 ;
25847 int ecode2 = 0 ;
25848 PyObject * obj0 = 0 ;
25849 PyObject * obj1 = 0 ;
25850 char * kwnames[] = {
25851 (char *) "self",(char *) "realized", NULL
25852 };
25853
25854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25858 }
25859 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25861 if (!SWIG_IsOK(ecode2)) {
25862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25863 }
25864 arg2 = static_cast< bool >(val2);
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 (arg1)->SetPaletteRealized(arg2);
25868 wxPyEndAllowThreads(__tstate);
25869 if (PyErr_Occurred()) SWIG_fail;
25870 }
25871 resultobj = SWIG_Py_Void();
25872 return resultobj;
25873 fail:
25874 return NULL;
25875 }
25876
25877
25878 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25879 PyObject *resultobj = 0;
25880 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25881 bool result;
25882 void *argp1 = 0 ;
25883 int res1 = 0 ;
25884 PyObject *swig_obj[1] ;
25885
25886 if (!args) SWIG_fail;
25887 swig_obj[0] = args;
25888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25891 }
25892 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 {
25900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25901 }
25902 return resultobj;
25903 fail:
25904 return NULL;
25905 }
25906
25907
25908 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25909 PyObject *obj;
25910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25911 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25912 return SWIG_Py_Void();
25913 }
25914
25915 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 return SWIG_Python_InitShadowInstance(args);
25917 }
25918
25919 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920 PyObject *resultobj = 0;
25921 wxNavigationKeyEvent *result = 0 ;
25922
25923 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25940 bool result;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 PyObject *swig_obj[1] ;
25944
25945 if (!args) SWIG_fail;
25946 swig_obj[0] = args;
25947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25950 }
25951 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 {
25959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25960 }
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25968 PyObject *resultobj = 0;
25969 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25970 bool arg2 ;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 bool val2 ;
25974 int ecode2 = 0 ;
25975 PyObject * obj0 = 0 ;
25976 PyObject * obj1 = 0 ;
25977 char * kwnames[] = {
25978 (char *) "self",(char *) "forward", NULL
25979 };
25980
25981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25985 }
25986 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25988 if (!SWIG_IsOK(ecode2)) {
25989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25990 }
25991 arg2 = static_cast< bool >(val2);
25992 {
25993 PyThreadState* __tstate = wxPyBeginAllowThreads();
25994 (arg1)->SetDirection(arg2);
25995 wxPyEndAllowThreads(__tstate);
25996 if (PyErr_Occurred()) SWIG_fail;
25997 }
25998 resultobj = SWIG_Py_Void();
25999 return resultobj;
26000 fail:
26001 return NULL;
26002 }
26003
26004
26005 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26006 PyObject *resultobj = 0;
26007 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26008 bool result;
26009 void *argp1 = 0 ;
26010 int res1 = 0 ;
26011 PyObject *swig_obj[1] ;
26012
26013 if (!args) SWIG_fail;
26014 swig_obj[0] = args;
26015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26018 }
26019 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 {
26027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26028 }
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj = 0;
26037 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26038 bool arg2 ;
26039 void *argp1 = 0 ;
26040 int res1 = 0 ;
26041 bool val2 ;
26042 int ecode2 = 0 ;
26043 PyObject * obj0 = 0 ;
26044 PyObject * obj1 = 0 ;
26045 char * kwnames[] = {
26046 (char *) "self",(char *) "ischange", NULL
26047 };
26048
26049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26053 }
26054 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26056 if (!SWIG_IsOK(ecode2)) {
26057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26058 }
26059 arg2 = static_cast< bool >(val2);
26060 {
26061 PyThreadState* __tstate = wxPyBeginAllowThreads();
26062 (arg1)->SetWindowChange(arg2);
26063 wxPyEndAllowThreads(__tstate);
26064 if (PyErr_Occurred()) SWIG_fail;
26065 }
26066 resultobj = SWIG_Py_Void();
26067 return resultobj;
26068 fail:
26069 return NULL;
26070 }
26071
26072
26073 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26074 PyObject *resultobj = 0;
26075 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26076 bool result;
26077 void *argp1 = 0 ;
26078 int res1 = 0 ;
26079 PyObject *swig_obj[1] ;
26080
26081 if (!args) SWIG_fail;
26082 swig_obj[0] = args;
26083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26084 if (!SWIG_IsOK(res1)) {
26085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26086 }
26087 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26091 wxPyEndAllowThreads(__tstate);
26092 if (PyErr_Occurred()) SWIG_fail;
26093 }
26094 {
26095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26096 }
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj = 0;
26105 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26106 bool arg2 ;
26107 void *argp1 = 0 ;
26108 int res1 = 0 ;
26109 bool val2 ;
26110 int ecode2 = 0 ;
26111 PyObject * obj0 = 0 ;
26112 PyObject * obj1 = 0 ;
26113 char * kwnames[] = {
26114 (char *) "self",(char *) "bIs", NULL
26115 };
26116
26117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26119 if (!SWIG_IsOK(res1)) {
26120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26121 }
26122 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26124 if (!SWIG_IsOK(ecode2)) {
26125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26126 }
26127 arg2 = static_cast< bool >(val2);
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 (arg1)->SetFromTab(arg2);
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 resultobj = SWIG_Py_Void();
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj = 0;
26143 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26144 long arg2 ;
26145 void *argp1 = 0 ;
26146 int res1 = 0 ;
26147 long val2 ;
26148 int ecode2 = 0 ;
26149 PyObject * obj0 = 0 ;
26150 PyObject * obj1 = 0 ;
26151 char * kwnames[] = {
26152 (char *) "self",(char *) "flags", NULL
26153 };
26154
26155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26159 }
26160 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26161 ecode2 = SWIG_AsVal_long(obj1, &val2);
26162 if (!SWIG_IsOK(ecode2)) {
26163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26164 }
26165 arg2 = static_cast< long >(val2);
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 (arg1)->SetFlags(arg2);
26169 wxPyEndAllowThreads(__tstate);
26170 if (PyErr_Occurred()) SWIG_fail;
26171 }
26172 resultobj = SWIG_Py_Void();
26173 return resultobj;
26174 fail:
26175 return NULL;
26176 }
26177
26178
26179 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26180 PyObject *resultobj = 0;
26181 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26182 wxWindow *result = 0 ;
26183 void *argp1 = 0 ;
26184 int res1 = 0 ;
26185 PyObject *swig_obj[1] ;
26186
26187 if (!args) SWIG_fail;
26188 swig_obj[0] = args;
26189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26192 }
26193 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 {
26201 resultobj = wxPyMake_wxObject(result, (bool)0);
26202 }
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj = 0;
26211 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26212 wxWindow *arg2 = (wxWindow *) 0 ;
26213 void *argp1 = 0 ;
26214 int res1 = 0 ;
26215 void *argp2 = 0 ;
26216 int res2 = 0 ;
26217 PyObject * obj0 = 0 ;
26218 PyObject * obj1 = 0 ;
26219 char * kwnames[] = {
26220 (char *) "self",(char *) "win", NULL
26221 };
26222
26223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26225 if (!SWIG_IsOK(res1)) {
26226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26227 }
26228 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26230 if (!SWIG_IsOK(res2)) {
26231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26232 }
26233 arg2 = reinterpret_cast< wxWindow * >(argp2);
26234 {
26235 PyThreadState* __tstate = wxPyBeginAllowThreads();
26236 (arg1)->SetCurrentFocus(arg2);
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 resultobj = SWIG_Py_Void();
26241 return resultobj;
26242 fail:
26243 return NULL;
26244 }
26245
26246
26247 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26248 PyObject *obj;
26249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26250 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26251 return SWIG_Py_Void();
26252 }
26253
26254 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26255 return SWIG_Python_InitShadowInstance(args);
26256 }
26257
26258 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26259 PyObject *resultobj = 0;
26260 wxWindow *arg1 = (wxWindow *) NULL ;
26261 wxWindowCreateEvent *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject * obj0 = 0 ;
26265 char * kwnames[] = {
26266 (char *) "win", NULL
26267 };
26268
26269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26270 if (obj0) {
26271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26274 }
26275 arg1 = reinterpret_cast< wxWindow * >(argp1);
26276 }
26277 {
26278 PyThreadState* __tstate = wxPyBeginAllowThreads();
26279 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26280 wxPyEndAllowThreads(__tstate);
26281 if (PyErr_Occurred()) SWIG_fail;
26282 }
26283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26291 PyObject *resultobj = 0;
26292 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26293 wxWindow *result = 0 ;
26294 void *argp1 = 0 ;
26295 int res1 = 0 ;
26296 PyObject *swig_obj[1] ;
26297
26298 if (!args) SWIG_fail;
26299 swig_obj[0] = args;
26300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26301 if (!SWIG_IsOK(res1)) {
26302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26303 }
26304 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 {
26312 resultobj = wxPyMake_wxObject(result, (bool)0);
26313 }
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26321 PyObject *obj;
26322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26323 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26324 return SWIG_Py_Void();
26325 }
26326
26327 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26328 return SWIG_Python_InitShadowInstance(args);
26329 }
26330
26331 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj = 0;
26333 wxWindow *arg1 = (wxWindow *) NULL ;
26334 wxWindowDestroyEvent *result = 0 ;
26335 void *argp1 = 0 ;
26336 int res1 = 0 ;
26337 PyObject * obj0 = 0 ;
26338 char * kwnames[] = {
26339 (char *) "win", NULL
26340 };
26341
26342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26343 if (obj0) {
26344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26345 if (!SWIG_IsOK(res1)) {
26346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26347 }
26348 arg1 = reinterpret_cast< wxWindow * >(argp1);
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *resultobj = 0;
26365 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26366 wxWindow *result = 0 ;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 PyObject *swig_obj[1] ;
26370
26371 if (!args) SWIG_fail;
26372 swig_obj[0] = args;
26373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26376 }
26377 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = wxPyMake_wxObject(result, (bool)0);
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26394 PyObject *obj;
26395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26396 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26397 return SWIG_Py_Void();
26398 }
26399
26400 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26401 return SWIG_Python_InitShadowInstance(args);
26402 }
26403
26404 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26405 PyObject *resultobj = 0;
26406 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26407 int arg2 = (int) 0 ;
26408 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26409 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26410 wxContextMenuEvent *result = 0 ;
26411 int val1 ;
26412 int ecode1 = 0 ;
26413 int val2 ;
26414 int ecode2 = 0 ;
26415 wxPoint temp3 ;
26416 PyObject * obj0 = 0 ;
26417 PyObject * obj1 = 0 ;
26418 PyObject * obj2 = 0 ;
26419 char * kwnames[] = {
26420 (char *) "type",(char *) "winid",(char *) "pt", NULL
26421 };
26422
26423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26424 if (obj0) {
26425 ecode1 = SWIG_AsVal_int(obj0, &val1);
26426 if (!SWIG_IsOK(ecode1)) {
26427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26428 }
26429 arg1 = static_cast< wxEventType >(val1);
26430 }
26431 if (obj1) {
26432 ecode2 = SWIG_AsVal_int(obj1, &val2);
26433 if (!SWIG_IsOK(ecode2)) {
26434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26435 }
26436 arg2 = static_cast< int >(val2);
26437 }
26438 if (obj2) {
26439 {
26440 arg3 = &temp3;
26441 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26442 }
26443 }
26444 {
26445 PyThreadState* __tstate = wxPyBeginAllowThreads();
26446 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26458 PyObject *resultobj = 0;
26459 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26460 wxPoint *result = 0 ;
26461 void *argp1 = 0 ;
26462 int res1 = 0 ;
26463 PyObject *swig_obj[1] ;
26464
26465 if (!args) SWIG_fail;
26466 swig_obj[0] = args;
26467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26468 if (!SWIG_IsOK(res1)) {
26469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26470 }
26471 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26472 {
26473 PyThreadState* __tstate = wxPyBeginAllowThreads();
26474 {
26475 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26476 result = (wxPoint *) &_result_ref;
26477 }
26478 wxPyEndAllowThreads(__tstate);
26479 if (PyErr_Occurred()) SWIG_fail;
26480 }
26481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26489 PyObject *resultobj = 0;
26490 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26491 wxPoint *arg2 = 0 ;
26492 void *argp1 = 0 ;
26493 int res1 = 0 ;
26494 wxPoint temp2 ;
26495 PyObject * obj0 = 0 ;
26496 PyObject * obj1 = 0 ;
26497 char * kwnames[] = {
26498 (char *) "self",(char *) "pos", NULL
26499 };
26500
26501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26503 if (!SWIG_IsOK(res1)) {
26504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26505 }
26506 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26507 {
26508 arg2 = &temp2;
26509 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26510 }
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 (arg1)->SetPosition((wxPoint const &)*arg2);
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 resultobj = SWIG_Py_Void();
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26525 PyObject *obj;
26526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26527 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26528 return SWIG_Py_Void();
26529 }
26530
26531 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26532 return SWIG_Python_InitShadowInstance(args);
26533 }
26534
26535 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26536 PyObject *resultobj = 0;
26537 wxIdleEvent *result = 0 ;
26538
26539 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26540 {
26541 PyThreadState* __tstate = wxPyBeginAllowThreads();
26542 result = (wxIdleEvent *)new wxIdleEvent();
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj = 0;
26555 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26556 bool arg2 = (bool) true ;
26557 void *argp1 = 0 ;
26558 int res1 = 0 ;
26559 bool val2 ;
26560 int ecode2 = 0 ;
26561 PyObject * obj0 = 0 ;
26562 PyObject * obj1 = 0 ;
26563 char * kwnames[] = {
26564 (char *) "self",(char *) "needMore", NULL
26565 };
26566
26567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26569 if (!SWIG_IsOK(res1)) {
26570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26571 }
26572 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26573 if (obj1) {
26574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26575 if (!SWIG_IsOK(ecode2)) {
26576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26577 }
26578 arg2 = static_cast< bool >(val2);
26579 }
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 (arg1)->RequestMore(arg2);
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_Py_Void();
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26594 PyObject *resultobj = 0;
26595 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26596 bool result;
26597 void *argp1 = 0 ;
26598 int res1 = 0 ;
26599 PyObject *swig_obj[1] ;
26600
26601 if (!args) SWIG_fail;
26602 swig_obj[0] = args;
26603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26604 if (!SWIG_IsOK(res1)) {
26605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26606 }
26607 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj = 0;
26625 wxIdleMode arg1 ;
26626 int val1 ;
26627 int ecode1 = 0 ;
26628 PyObject * obj0 = 0 ;
26629 char * kwnames[] = {
26630 (char *) "mode", NULL
26631 };
26632
26633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26634 ecode1 = SWIG_AsVal_int(obj0, &val1);
26635 if (!SWIG_IsOK(ecode1)) {
26636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26637 }
26638 arg1 = static_cast< wxIdleMode >(val1);
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 wxIdleEvent::SetMode(arg1);
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 resultobj = SWIG_Py_Void();
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26653 PyObject *resultobj = 0;
26654 wxIdleMode result;
26655
26656 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (wxIdleMode)wxIdleEvent::GetMode();
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_From_int(static_cast< int >(result));
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26671 PyObject *resultobj = 0;
26672 wxWindow *arg1 = (wxWindow *) 0 ;
26673 bool result;
26674 void *argp1 = 0 ;
26675 int res1 = 0 ;
26676 PyObject * obj0 = 0 ;
26677 char * kwnames[] = {
26678 (char *) "win", NULL
26679 };
26680
26681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26683 if (!SWIG_IsOK(res1)) {
26684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26685 }
26686 arg1 = reinterpret_cast< wxWindow * >(argp1);
26687 {
26688 PyThreadState* __tstate = wxPyBeginAllowThreads();
26689 result = (bool)wxIdleEvent::CanSend(arg1);
26690 wxPyEndAllowThreads(__tstate);
26691 if (PyErr_Occurred()) SWIG_fail;
26692 }
26693 {
26694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26695 }
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 PyObject *obj;
26704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26705 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26706 return SWIG_Py_Void();
26707 }
26708
26709 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26710 return SWIG_Python_InitShadowInstance(args);
26711 }
26712
26713 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26714 PyObject *resultobj = 0;
26715 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26716 int arg2 = (int) 0 ;
26717 wxClipboardTextEvent *result = 0 ;
26718 int val1 ;
26719 int ecode1 = 0 ;
26720 int val2 ;
26721 int ecode2 = 0 ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 char * kwnames[] = {
26725 (char *) "type",(char *) "winid", NULL
26726 };
26727
26728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26729 if (obj0) {
26730 ecode1 = SWIG_AsVal_int(obj0, &val1);
26731 if (!SWIG_IsOK(ecode1)) {
26732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26733 }
26734 arg1 = static_cast< wxEventType >(val1);
26735 }
26736 if (obj1) {
26737 ecode2 = SWIG_AsVal_int(obj1, &val2);
26738 if (!SWIG_IsOK(ecode2)) {
26739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26740 }
26741 arg2 = static_cast< int >(val2);
26742 }
26743 {
26744 PyThreadState* __tstate = wxPyBeginAllowThreads();
26745 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26746 wxPyEndAllowThreads(__tstate);
26747 if (PyErr_Occurred()) SWIG_fail;
26748 }
26749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26750 return resultobj;
26751 fail:
26752 return NULL;
26753 }
26754
26755
26756 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26757 PyObject *obj;
26758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26759 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26760 return SWIG_Py_Void();
26761 }
26762
26763 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26764 return SWIG_Python_InitShadowInstance(args);
26765 }
26766
26767 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj = 0;
26769 int arg1 = (int) 0 ;
26770 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26771 wxPyEvent *result = 0 ;
26772 int val1 ;
26773 int ecode1 = 0 ;
26774 int val2 ;
26775 int ecode2 = 0 ;
26776 PyObject * obj0 = 0 ;
26777 PyObject * obj1 = 0 ;
26778 char * kwnames[] = {
26779 (char *) "winid",(char *) "eventType", NULL
26780 };
26781
26782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26783 if (obj0) {
26784 ecode1 = SWIG_AsVal_int(obj0, &val1);
26785 if (!SWIG_IsOK(ecode1)) {
26786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26787 }
26788 arg1 = static_cast< int >(val1);
26789 }
26790 if (obj1) {
26791 ecode2 = SWIG_AsVal_int(obj1, &val2);
26792 if (!SWIG_IsOK(ecode2)) {
26793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26794 }
26795 arg2 = static_cast< wxEventType >(val2);
26796 }
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26811 PyObject *resultobj = 0;
26812 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26813 void *argp1 = 0 ;
26814 int res1 = 0 ;
26815 PyObject *swig_obj[1] ;
26816
26817 if (!args) SWIG_fail;
26818 swig_obj[0] = args;
26819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26822 }
26823 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 delete arg1;
26827
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 resultobj = SWIG_Py_Void();
26832 return resultobj;
26833 fail:
26834 return NULL;
26835 }
26836
26837
26838 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj = 0;
26840 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26841 PyObject *arg2 = (PyObject *) 0 ;
26842 void *argp1 = 0 ;
26843 int res1 = 0 ;
26844 PyObject * obj0 = 0 ;
26845 PyObject * obj1 = 0 ;
26846 char * kwnames[] = {
26847 (char *) "self",(char *) "self", NULL
26848 };
26849
26850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26852 if (!SWIG_IsOK(res1)) {
26853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26854 }
26855 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26856 arg2 = obj1;
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 (arg1)->SetSelf(arg2);
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 resultobj = SWIG_Py_Void();
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26871 PyObject *resultobj = 0;
26872 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26873 PyObject *result = 0 ;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 PyObject *swig_obj[1] ;
26877
26878 if (!args) SWIG_fail;
26879 swig_obj[0] = args;
26880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26881 if (!SWIG_IsOK(res1)) {
26882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26883 }
26884 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = (PyObject *)(arg1)->GetSelf();
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 resultobj = result;
26892 return resultobj;
26893 fail:
26894 return NULL;
26895 }
26896
26897
26898 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26899 PyObject *obj;
26900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26901 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26902 return SWIG_Py_Void();
26903 }
26904
26905 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26906 return SWIG_Python_InitShadowInstance(args);
26907 }
26908
26909 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26910 PyObject *resultobj = 0;
26911 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26912 int arg2 = (int) 0 ;
26913 wxPyCommandEvent *result = 0 ;
26914 int val1 ;
26915 int ecode1 = 0 ;
26916 int val2 ;
26917 int ecode2 = 0 ;
26918 PyObject * obj0 = 0 ;
26919 PyObject * obj1 = 0 ;
26920 char * kwnames[] = {
26921 (char *) "eventType",(char *) "id", NULL
26922 };
26923
26924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26925 if (obj0) {
26926 ecode1 = SWIG_AsVal_int(obj0, &val1);
26927 if (!SWIG_IsOK(ecode1)) {
26928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26929 }
26930 arg1 = static_cast< wxEventType >(val1);
26931 }
26932 if (obj1) {
26933 ecode2 = SWIG_AsVal_int(obj1, &val2);
26934 if (!SWIG_IsOK(ecode2)) {
26935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26936 }
26937 arg2 = static_cast< int >(val2);
26938 }
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26942 wxPyEndAllowThreads(__tstate);
26943 if (PyErr_Occurred()) SWIG_fail;
26944 }
26945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26953 PyObject *resultobj = 0;
26954 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26955 void *argp1 = 0 ;
26956 int res1 = 0 ;
26957 PyObject *swig_obj[1] ;
26958
26959 if (!args) SWIG_fail;
26960 swig_obj[0] = args;
26961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26962 if (!SWIG_IsOK(res1)) {
26963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26964 }
26965 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 delete arg1;
26969
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 resultobj = SWIG_Py_Void();
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj = 0;
26982 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26983 PyObject *arg2 = (PyObject *) 0 ;
26984 void *argp1 = 0 ;
26985 int res1 = 0 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "self", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26996 }
26997 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26998 arg2 = obj1;
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 (arg1)->SetSelf(arg2);
27002 wxPyEndAllowThreads(__tstate);
27003 if (PyErr_Occurred()) SWIG_fail;
27004 }
27005 resultobj = SWIG_Py_Void();
27006 return resultobj;
27007 fail:
27008 return NULL;
27009 }
27010
27011
27012 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27013 PyObject *resultobj = 0;
27014 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27015 PyObject *result = 0 ;
27016 void *argp1 = 0 ;
27017 int res1 = 0 ;
27018 PyObject *swig_obj[1] ;
27019
27020 if (!args) SWIG_fail;
27021 swig_obj[0] = args;
27022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27023 if (!SWIG_IsOK(res1)) {
27024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27025 }
27026 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 result = (PyObject *)(arg1)->GetSelf();
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 resultobj = result;
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27041 PyObject *obj;
27042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27043 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27044 return SWIG_Py_Void();
27045 }
27046
27047 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27048 return SWIG_Python_InitShadowInstance(args);
27049 }
27050
27051 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj = 0;
27053 wxWindow *arg1 = (wxWindow *) 0 ;
27054 wxDateTime *arg2 = 0 ;
27055 wxEventType arg3 ;
27056 wxDateEvent *result = 0 ;
27057 void *argp1 = 0 ;
27058 int res1 = 0 ;
27059 void *argp2 = 0 ;
27060 int res2 = 0 ;
27061 int val3 ;
27062 int ecode3 = 0 ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 PyObject * obj2 = 0 ;
27066 char * kwnames[] = {
27067 (char *) "win",(char *) "dt",(char *) "type", NULL
27068 };
27069
27070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27072 if (!SWIG_IsOK(res1)) {
27073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27074 }
27075 arg1 = reinterpret_cast< wxWindow * >(argp1);
27076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27077 if (!SWIG_IsOK(res2)) {
27078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27079 }
27080 if (!argp2) {
27081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27082 }
27083 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27084 ecode3 = SWIG_AsVal_int(obj2, &val3);
27085 if (!SWIG_IsOK(ecode3)) {
27086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27087 }
27088 arg3 = static_cast< wxEventType >(val3);
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27103 PyObject *resultobj = 0;
27104 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27105 wxDateTime *result = 0 ;
27106 void *argp1 = 0 ;
27107 int res1 = 0 ;
27108 PyObject *swig_obj[1] ;
27109
27110 if (!args) SWIG_fail;
27111 swig_obj[0] = args;
27112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27113 if (!SWIG_IsOK(res1)) {
27114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27115 }
27116 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 {
27120 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27121 result = (wxDateTime *) &_result_ref;
27122 }
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27134 PyObject *resultobj = 0;
27135 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27136 wxDateTime *arg2 = 0 ;
27137 void *argp1 = 0 ;
27138 int res1 = 0 ;
27139 void *argp2 = 0 ;
27140 int res2 = 0 ;
27141 PyObject * obj0 = 0 ;
27142 PyObject * obj1 = 0 ;
27143 char * kwnames[] = {
27144 (char *) "self",(char *) "date", NULL
27145 };
27146
27147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27149 if (!SWIG_IsOK(res1)) {
27150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27151 }
27152 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27154 if (!SWIG_IsOK(res2)) {
27155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27156 }
27157 if (!argp2) {
27158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27159 }
27160 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 (arg1)->SetDate((wxDateTime const &)*arg2);
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 resultobj = SWIG_Py_Void();
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27175 PyObject *obj;
27176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27177 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27178 return SWIG_Py_Void();
27179 }
27180
27181 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 return SWIG_Python_InitShadowInstance(args);
27183 }
27184
27185 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27186 PyObject *resultobj = 0;
27187 wxPyApp *result = 0 ;
27188
27189 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27190 {
27191 PyThreadState* __tstate = wxPyBeginAllowThreads();
27192 result = (wxPyApp *)new_wxPyApp();
27193 wxPyEndAllowThreads(__tstate);
27194 if (PyErr_Occurred()) SWIG_fail;
27195 }
27196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27197 return resultobj;
27198 fail:
27199 return NULL;
27200 }
27201
27202
27203 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27204 PyObject *resultobj = 0;
27205 wxPyApp *arg1 = (wxPyApp *) 0 ;
27206 void *argp1 = 0 ;
27207 int res1 = 0 ;
27208 PyObject *swig_obj[1] ;
27209
27210 if (!args) SWIG_fail;
27211 swig_obj[0] = args;
27212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27215 }
27216 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 delete arg1;
27220
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 resultobj = SWIG_Py_Void();
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj = 0;
27233 wxPyApp *arg1 = (wxPyApp *) 0 ;
27234 PyObject *arg2 = (PyObject *) 0 ;
27235 PyObject *arg3 = (PyObject *) 0 ;
27236 bool arg4 ;
27237 void *argp1 = 0 ;
27238 int res1 = 0 ;
27239 bool val4 ;
27240 int ecode4 = 0 ;
27241 PyObject * obj0 = 0 ;
27242 PyObject * obj1 = 0 ;
27243 PyObject * obj2 = 0 ;
27244 PyObject * obj3 = 0 ;
27245 char * kwnames[] = {
27246 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27247 };
27248
27249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27251 if (!SWIG_IsOK(res1)) {
27252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27253 }
27254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27255 arg2 = obj1;
27256 arg3 = obj2;
27257 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27258 if (!SWIG_IsOK(ecode4)) {
27259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27260 }
27261 arg4 = static_cast< bool >(val4);
27262 {
27263 PyThreadState* __tstate = wxPyBeginAllowThreads();
27264 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 resultobj = SWIG_Py_Void();
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27276 PyObject *resultobj = 0;
27277 wxPyApp *arg1 = (wxPyApp *) 0 ;
27278 wxString 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_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27288 }
27289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27290 {
27291 PyThreadState* __tstate = wxPyBeginAllowThreads();
27292 result = ((wxPyApp const *)arg1)->GetAppName();
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 #if wxUSE_UNICODE
27298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27299 #else
27300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27301 #endif
27302 }
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj = 0;
27311 wxPyApp *arg1 = (wxPyApp *) 0 ;
27312 wxString *arg2 = 0 ;
27313 void *argp1 = 0 ;
27314 int res1 = 0 ;
27315 bool temp2 = false ;
27316 PyObject * obj0 = 0 ;
27317 PyObject * obj1 = 0 ;
27318 char * kwnames[] = {
27319 (char *) "self",(char *) "name", NULL
27320 };
27321
27322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27324 if (!SWIG_IsOK(res1)) {
27325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27326 }
27327 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27328 {
27329 arg2 = wxString_in_helper(obj1);
27330 if (arg2 == NULL) SWIG_fail;
27331 temp2 = true;
27332 }
27333 {
27334 PyThreadState* __tstate = wxPyBeginAllowThreads();
27335 (arg1)->SetAppName((wxString const &)*arg2);
27336 wxPyEndAllowThreads(__tstate);
27337 if (PyErr_Occurred()) SWIG_fail;
27338 }
27339 resultobj = SWIG_Py_Void();
27340 {
27341 if (temp2)
27342 delete arg2;
27343 }
27344 return resultobj;
27345 fail:
27346 {
27347 if (temp2)
27348 delete arg2;
27349 }
27350 return NULL;
27351 }
27352
27353
27354 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27355 PyObject *resultobj = 0;
27356 wxPyApp *arg1 = (wxPyApp *) 0 ;
27357 wxString result;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 PyObject *swig_obj[1] ;
27361
27362 if (!args) SWIG_fail;
27363 swig_obj[0] = args;
27364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 result = ((wxPyApp const *)arg1)->GetClassName();
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 #if wxUSE_UNICODE
27377 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27378 #else
27379 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27380 #endif
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 wxString *arg2 = 0 ;
27392 void *argp1 = 0 ;
27393 int res1 = 0 ;
27394 bool temp2 = false ;
27395 PyObject * obj0 = 0 ;
27396 PyObject * obj1 = 0 ;
27397 char * kwnames[] = {
27398 (char *) "self",(char *) "name", NULL
27399 };
27400
27401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27403 if (!SWIG_IsOK(res1)) {
27404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27405 }
27406 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27407 {
27408 arg2 = wxString_in_helper(obj1);
27409 if (arg2 == NULL) SWIG_fail;
27410 temp2 = true;
27411 }
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 (arg1)->SetClassName((wxString const &)*arg2);
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 resultobj = SWIG_Py_Void();
27419 {
27420 if (temp2)
27421 delete arg2;
27422 }
27423 return resultobj;
27424 fail:
27425 {
27426 if (temp2)
27427 delete arg2;
27428 }
27429 return NULL;
27430 }
27431
27432
27433 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27434 PyObject *resultobj = 0;
27435 wxPyApp *arg1 = (wxPyApp *) 0 ;
27436 wxString *result = 0 ;
27437 void *argp1 = 0 ;
27438 int res1 = 0 ;
27439 PyObject *swig_obj[1] ;
27440
27441 if (!args) SWIG_fail;
27442 swig_obj[0] = args;
27443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27444 if (!SWIG_IsOK(res1)) {
27445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27446 }
27447 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27448 {
27449 PyThreadState* __tstate = wxPyBeginAllowThreads();
27450 {
27451 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27452 result = (wxString *) &_result_ref;
27453 }
27454 wxPyEndAllowThreads(__tstate);
27455 if (PyErr_Occurred()) SWIG_fail;
27456 }
27457 {
27458 #if wxUSE_UNICODE
27459 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27460 #else
27461 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27462 #endif
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj = 0;
27472 wxPyApp *arg1 = (wxPyApp *) 0 ;
27473 wxString *arg2 = 0 ;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 bool temp2 = false ;
27477 PyObject * obj0 = 0 ;
27478 PyObject * obj1 = 0 ;
27479 char * kwnames[] = {
27480 (char *) "self",(char *) "name", NULL
27481 };
27482
27483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27485 if (!SWIG_IsOK(res1)) {
27486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27487 }
27488 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27489 {
27490 arg2 = wxString_in_helper(obj1);
27491 if (arg2 == NULL) SWIG_fail;
27492 temp2 = true;
27493 }
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 (arg1)->SetVendorName((wxString const &)*arg2);
27497 wxPyEndAllowThreads(__tstate);
27498 if (PyErr_Occurred()) SWIG_fail;
27499 }
27500 resultobj = SWIG_Py_Void();
27501 {
27502 if (temp2)
27503 delete arg2;
27504 }
27505 return resultobj;
27506 fail:
27507 {
27508 if (temp2)
27509 delete arg2;
27510 }
27511 return NULL;
27512 }
27513
27514
27515 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27516 PyObject *resultobj = 0;
27517 wxPyApp *arg1 = (wxPyApp *) 0 ;
27518 wxAppTraits *result = 0 ;
27519 void *argp1 = 0 ;
27520 int res1 = 0 ;
27521 PyObject *swig_obj[1] ;
27522
27523 if (!args) SWIG_fail;
27524 swig_obj[0] = args;
27525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27526 if (!SWIG_IsOK(res1)) {
27527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27528 }
27529 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 result = (wxAppTraits *)(arg1)->GetTraits();
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27537 return resultobj;
27538 fail:
27539 return NULL;
27540 }
27541
27542
27543 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27544 PyObject *resultobj = 0;
27545 wxPyApp *arg1 = (wxPyApp *) 0 ;
27546 void *argp1 = 0 ;
27547 int res1 = 0 ;
27548 PyObject *swig_obj[1] ;
27549
27550 if (!args) SWIG_fail;
27551 swig_obj[0] = args;
27552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27553 if (!SWIG_IsOK(res1)) {
27554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27555 }
27556 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 (arg1)->ProcessPendingEvents();
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_Py_Void();
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27571 PyObject *resultobj = 0;
27572 wxPyApp *arg1 = (wxPyApp *) 0 ;
27573 bool arg2 = (bool) false ;
27574 bool result;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 bool val2 ;
27578 int ecode2 = 0 ;
27579 PyObject * obj0 = 0 ;
27580 PyObject * obj1 = 0 ;
27581 char * kwnames[] = {
27582 (char *) "self",(char *) "onlyIfNeeded", NULL
27583 };
27584
27585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27587 if (!SWIG_IsOK(res1)) {
27588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27589 }
27590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27591 if (obj1) {
27592 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27593 if (!SWIG_IsOK(ecode2)) {
27594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27595 }
27596 arg2 = static_cast< bool >(val2);
27597 }
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (bool)(arg1)->Yield(arg2);
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 {
27605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27606 }
27607 return resultobj;
27608 fail:
27609 return NULL;
27610 }
27611
27612
27613 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27614 PyObject *resultobj = 0;
27615 wxPyApp *arg1 = (wxPyApp *) 0 ;
27616 void *argp1 = 0 ;
27617 int res1 = 0 ;
27618 PyObject *swig_obj[1] ;
27619
27620 if (!args) SWIG_fail;
27621 swig_obj[0] = args;
27622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27623 if (!SWIG_IsOK(res1)) {
27624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27625 }
27626 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 (arg1)->WakeUpIdle();
27630 wxPyEndAllowThreads(__tstate);
27631 if (PyErr_Occurred()) SWIG_fail;
27632 }
27633 resultobj = SWIG_Py_Void();
27634 return resultobj;
27635 fail:
27636 return NULL;
27637 }
27638
27639
27640 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27641 PyObject *resultobj = 0;
27642 bool result;
27643
27644 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 result = (bool)wxPyApp::IsMainLoopRunning();
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 {
27652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27653 }
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(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_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27673 }
27674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = (int)(arg1)->MainLoop();
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_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27689 PyObject *resultobj = 0;
27690 wxPyApp *arg1 = (wxPyApp *) 0 ;
27691 void *argp1 = 0 ;
27692 int res1 = 0 ;
27693 PyObject *swig_obj[1] ;
27694
27695 if (!args) SWIG_fail;
27696 swig_obj[0] = args;
27697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27698 if (!SWIG_IsOK(res1)) {
27699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27700 }
27701 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27702 {
27703 PyThreadState* __tstate = wxPyBeginAllowThreads();
27704 (arg1)->Exit();
27705 wxPyEndAllowThreads(__tstate);
27706 if (PyErr_Occurred()) SWIG_fail;
27707 }
27708 resultobj = SWIG_Py_Void();
27709 return resultobj;
27710 fail:
27711 return NULL;
27712 }
27713
27714
27715 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27716 PyObject *resultobj = 0;
27717 wxPyApp *arg1 = (wxPyApp *) 0 ;
27718 void *argp1 = 0 ;
27719 int res1 = 0 ;
27720 PyObject *swig_obj[1] ;
27721
27722 if (!args) SWIG_fail;
27723 swig_obj[0] = args;
27724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27725 if (!SWIG_IsOK(res1)) {
27726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27727 }
27728 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 (arg1)->ExitMainLoop();
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 resultobj = SWIG_Py_Void();
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27743 PyObject *resultobj = 0;
27744 wxPyApp *arg1 = (wxPyApp *) 0 ;
27745 bool result;
27746 void *argp1 = 0 ;
27747 int res1 = 0 ;
27748 PyObject *swig_obj[1] ;
27749
27750 if (!args) SWIG_fail;
27751 swig_obj[0] = args;
27752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27753 if (!SWIG_IsOK(res1)) {
27754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27755 }
27756 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 result = (bool)(arg1)->Pending();
27760 wxPyEndAllowThreads(__tstate);
27761 if (PyErr_Occurred()) SWIG_fail;
27762 }
27763 {
27764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27765 }
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27773 PyObject *resultobj = 0;
27774 wxPyApp *arg1 = (wxPyApp *) 0 ;
27775 bool result;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 PyObject *swig_obj[1] ;
27779
27780 if (!args) SWIG_fail;
27781 swig_obj[0] = args;
27782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27783 if (!SWIG_IsOK(res1)) {
27784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27785 }
27786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = (bool)(arg1)->Dispatch();
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 {
27794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27795 }
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *resultobj = 0;
27804 wxPyApp *arg1 = (wxPyApp *) 0 ;
27805 bool result;
27806 void *argp1 = 0 ;
27807 int res1 = 0 ;
27808 PyObject *swig_obj[1] ;
27809
27810 if (!args) SWIG_fail;
27811 swig_obj[0] = args;
27812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27813 if (!SWIG_IsOK(res1)) {
27814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27815 }
27816 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 result = (bool)(arg1)->ProcessIdle();
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 {
27824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj = 0;
27834 wxPyApp *arg1 = (wxPyApp *) 0 ;
27835 wxWindow *arg2 = (wxWindow *) 0 ;
27836 wxIdleEvent *arg3 = 0 ;
27837 bool result;
27838 void *argp1 = 0 ;
27839 int res1 = 0 ;
27840 void *argp2 = 0 ;
27841 int res2 = 0 ;
27842 void *argp3 = 0 ;
27843 int res3 = 0 ;
27844 PyObject * obj0 = 0 ;
27845 PyObject * obj1 = 0 ;
27846 PyObject * obj2 = 0 ;
27847 char * kwnames[] = {
27848 (char *) "self",(char *) "win",(char *) "event", NULL
27849 };
27850
27851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27855 }
27856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27858 if (!SWIG_IsOK(res2)) {
27859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27860 }
27861 arg2 = reinterpret_cast< wxWindow * >(argp2);
27862 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27863 if (!SWIG_IsOK(res3)) {
27864 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27865 }
27866 if (!argp3) {
27867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27868 }
27869 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 {
27877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxPyApp *arg1 = (wxPyApp *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxPyApp const *)arg1)->IsActive();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27916 PyObject *resultobj = 0;
27917 wxPyApp *arg1 = (wxPyApp *) 0 ;
27918 wxWindow *arg2 = (wxWindow *) 0 ;
27919 void *argp1 = 0 ;
27920 int res1 = 0 ;
27921 void *argp2 = 0 ;
27922 int res2 = 0 ;
27923 PyObject * obj0 = 0 ;
27924 PyObject * obj1 = 0 ;
27925 char * kwnames[] = {
27926 (char *) "self",(char *) "win", NULL
27927 };
27928
27929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27931 if (!SWIG_IsOK(res1)) {
27932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27933 }
27934 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27936 if (!SWIG_IsOK(res2)) {
27937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27938 }
27939 arg2 = reinterpret_cast< wxWindow * >(argp2);
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 (arg1)->SetTopWindow(arg2);
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 resultobj = SWIG_Py_Void();
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27954 PyObject *resultobj = 0;
27955 wxPyApp *arg1 = (wxPyApp *) 0 ;
27956 wxWindow *result = 0 ;
27957 void *argp1 = 0 ;
27958 int res1 = 0 ;
27959 PyObject *swig_obj[1] ;
27960
27961 if (!args) SWIG_fail;
27962 swig_obj[0] = args;
27963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27964 if (!SWIG_IsOK(res1)) {
27965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27966 }
27967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27968 {
27969 PyThreadState* __tstate = wxPyBeginAllowThreads();
27970 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27971 wxPyEndAllowThreads(__tstate);
27972 if (PyErr_Occurred()) SWIG_fail;
27973 }
27974 {
27975 resultobj = wxPyMake_wxObject(result, (bool)0);
27976 }
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj = 0;
27985 wxPyApp *arg1 = (wxPyApp *) 0 ;
27986 bool arg2 ;
27987 void *argp1 = 0 ;
27988 int res1 = 0 ;
27989 bool val2 ;
27990 int ecode2 = 0 ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char * kwnames[] = {
27994 (char *) "self",(char *) "flag", NULL
27995 };
27996
27997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28001 }
28002 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28004 if (!SWIG_IsOK(ecode2)) {
28005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28006 }
28007 arg2 = static_cast< bool >(val2);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->SetExitOnFrameDelete(arg2);
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_Py_Void();
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 wxPyApp *arg1 = (wxPyApp *) 0 ;
28024 bool result;
28025 void *argp1 = 0 ;
28026 int res1 = 0 ;
28027 PyObject *swig_obj[1] ;
28028
28029 if (!args) SWIG_fail;
28030 swig_obj[0] = args;
28031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28032 if (!SWIG_IsOK(res1)) {
28033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28034 }
28035 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 {
28043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28044 }
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj = 0;
28053 wxPyApp *arg1 = (wxPyApp *) 0 ;
28054 bool arg2 ;
28055 void *argp1 = 0 ;
28056 int res1 = 0 ;
28057 bool val2 ;
28058 int ecode2 = 0 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char * kwnames[] = {
28062 (char *) "self",(char *) "flag", NULL
28063 };
28064
28065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28067 if (!SWIG_IsOK(res1)) {
28068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28069 }
28070 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28072 if (!SWIG_IsOK(ecode2)) {
28073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28074 }
28075 arg2 = static_cast< bool >(val2);
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 (arg1)->SetUseBestVisual(arg2);
28079 wxPyEndAllowThreads(__tstate);
28080 if (PyErr_Occurred()) SWIG_fail;
28081 }
28082 resultobj = SWIG_Py_Void();
28083 return resultobj;
28084 fail:
28085 return NULL;
28086 }
28087
28088
28089 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28090 PyObject *resultobj = 0;
28091 wxPyApp *arg1 = (wxPyApp *) 0 ;
28092 bool result;
28093 void *argp1 = 0 ;
28094 int res1 = 0 ;
28095 PyObject *swig_obj[1] ;
28096
28097 if (!args) SWIG_fail;
28098 swig_obj[0] = args;
28099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28100 if (!SWIG_IsOK(res1)) {
28101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28102 }
28103 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj = 0;
28121 wxPyApp *arg1 = (wxPyApp *) 0 ;
28122 int arg2 ;
28123 void *argp1 = 0 ;
28124 int res1 = 0 ;
28125 int val2 ;
28126 int ecode2 = 0 ;
28127 PyObject * obj0 = 0 ;
28128 PyObject * obj1 = 0 ;
28129 char * kwnames[] = {
28130 (char *) "self",(char *) "mode", NULL
28131 };
28132
28133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28135 if (!SWIG_IsOK(res1)) {
28136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28137 }
28138 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28139 ecode2 = SWIG_AsVal_int(obj1, &val2);
28140 if (!SWIG_IsOK(ecode2)) {
28141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28142 }
28143 arg2 = static_cast< int >(val2);
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 (arg1)->SetPrintMode(arg2);
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 resultobj = SWIG_Py_Void();
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28158 PyObject *resultobj = 0;
28159 wxPyApp *arg1 = (wxPyApp *) 0 ;
28160 int result;
28161 void *argp1 = 0 ;
28162 int res1 = 0 ;
28163 PyObject *swig_obj[1] ;
28164
28165 if (!args) SWIG_fail;
28166 swig_obj[0] = args;
28167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28168 if (!SWIG_IsOK(res1)) {
28169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28170 }
28171 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_From_int(static_cast< int >(result));
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28186 PyObject *resultobj = 0;
28187 wxPyApp *arg1 = (wxPyApp *) 0 ;
28188 int arg2 ;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 int val2 ;
28192 int ecode2 = 0 ;
28193 PyObject * obj0 = 0 ;
28194 PyObject * obj1 = 0 ;
28195 char * kwnames[] = {
28196 (char *) "self",(char *) "mode", NULL
28197 };
28198
28199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28201 if (!SWIG_IsOK(res1)) {
28202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28203 }
28204 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28205 ecode2 = SWIG_AsVal_int(obj1, &val2);
28206 if (!SWIG_IsOK(ecode2)) {
28207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28208 }
28209 arg2 = static_cast< int >(val2);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 (arg1)->SetAssertMode(arg2);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_Py_Void();
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28224 PyObject *resultobj = 0;
28225 wxPyApp *arg1 = (wxPyApp *) 0 ;
28226 int result;
28227 void *argp1 = 0 ;
28228 int res1 = 0 ;
28229 PyObject *swig_obj[1] ;
28230
28231 if (!args) SWIG_fail;
28232 swig_obj[0] = args;
28233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28234 if (!SWIG_IsOK(res1)) {
28235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28236 }
28237 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (int)(arg1)->GetAssertMode();
28241 wxPyEndAllowThreads(__tstate);
28242 if (PyErr_Occurred()) SWIG_fail;
28243 }
28244 resultobj = SWIG_From_int(static_cast< int >(result));
28245 return resultobj;
28246 fail:
28247 return NULL;
28248 }
28249
28250
28251 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28252 PyObject *resultobj = 0;
28253 bool result;
28254
28255 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 {
28263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28264 }
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28272 PyObject *resultobj = 0;
28273 long result;
28274
28275 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 result = (long)wxPyApp::GetMacAboutMenuItemId();
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_From_long(static_cast< long >(result));
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 long result;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_From_long(static_cast< long >(result));
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 long result;
28310
28311 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (long)wxPyApp::GetMacExitMenuItemId();
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_From_long(static_cast< long >(result));
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28326 PyObject *resultobj = 0;
28327 wxString result;
28328
28329 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = wxPyApp::GetMacHelpMenuTitleName();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 {
28337 #if wxUSE_UNICODE
28338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28339 #else
28340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28341 #endif
28342 }
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28350 PyObject *resultobj = 0;
28351 bool arg1 ;
28352 bool val1 ;
28353 int ecode1 = 0 ;
28354 PyObject * obj0 = 0 ;
28355 char * kwnames[] = {
28356 (char *) "val", NULL
28357 };
28358
28359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28360 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28361 if (!SWIG_IsOK(ecode1)) {
28362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28363 }
28364 arg1 = static_cast< bool >(val1);
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 resultobj = SWIG_Py_Void();
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj = 0;
28380 long arg1 ;
28381 long val1 ;
28382 int ecode1 = 0 ;
28383 PyObject * obj0 = 0 ;
28384 char * kwnames[] = {
28385 (char *) "val", NULL
28386 };
28387
28388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28389 ecode1 = SWIG_AsVal_long(obj0, &val1);
28390 if (!SWIG_IsOK(ecode1)) {
28391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28392 }
28393 arg1 = static_cast< long >(val1);
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 wxPyApp::SetMacAboutMenuItemId(arg1);
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_Py_Void();
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28408 PyObject *resultobj = 0;
28409 long arg1 ;
28410 long val1 ;
28411 int ecode1 = 0 ;
28412 PyObject * obj0 = 0 ;
28413 char * kwnames[] = {
28414 (char *) "val", NULL
28415 };
28416
28417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28418 ecode1 = SWIG_AsVal_long(obj0, &val1);
28419 if (!SWIG_IsOK(ecode1)) {
28420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28421 }
28422 arg1 = static_cast< long >(val1);
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_Py_Void();
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 long arg1 ;
28439 long val1 ;
28440 int ecode1 = 0 ;
28441 PyObject * obj0 = 0 ;
28442 char * kwnames[] = {
28443 (char *) "val", NULL
28444 };
28445
28446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28447 ecode1 = SWIG_AsVal_long(obj0, &val1);
28448 if (!SWIG_IsOK(ecode1)) {
28449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28450 }
28451 arg1 = static_cast< long >(val1);
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 wxPyApp::SetMacExitMenuItemId(arg1);
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 resultobj = SWIG_Py_Void();
28459 return resultobj;
28460 fail:
28461 return NULL;
28462 }
28463
28464
28465 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28466 PyObject *resultobj = 0;
28467 wxString *arg1 = 0 ;
28468 bool temp1 = false ;
28469 PyObject * obj0 = 0 ;
28470 char * kwnames[] = {
28471 (char *) "val", NULL
28472 };
28473
28474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28475 {
28476 arg1 = wxString_in_helper(obj0);
28477 if (arg1 == NULL) SWIG_fail;
28478 temp1 = true;
28479 }
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_Py_Void();
28487 {
28488 if (temp1)
28489 delete arg1;
28490 }
28491 return resultobj;
28492 fail:
28493 {
28494 if (temp1)
28495 delete arg1;
28496 }
28497 return NULL;
28498 }
28499
28500
28501 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28502 PyObject *resultobj = 0;
28503 wxPyApp *arg1 = (wxPyApp *) 0 ;
28504 void *argp1 = 0 ;
28505 int res1 = 0 ;
28506 PyObject *swig_obj[1] ;
28507
28508 if (!args) SWIG_fail;
28509 swig_obj[0] = args;
28510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28511 if (!SWIG_IsOK(res1)) {
28512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28513 }
28514 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 (arg1)->_BootstrapApp();
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 resultobj = SWIG_Py_Void();
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 int result;
28531
28532 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (int)wxPyApp_GetComCtl32Version();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_From_int(static_cast< int >(result));
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28547 PyObject *resultobj = 0;
28548 bool result;
28549
28550 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = (bool)wxPyApp_DisplayAvailable();
28554 wxPyEndAllowThreads(__tstate);
28555 if (PyErr_Occurred()) SWIG_fail;
28556 }
28557 {
28558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28559 }
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28567 PyObject *obj;
28568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28570 return SWIG_Py_Void();
28571 }
28572
28573 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 return SWIG_Python_InitShadowInstance(args);
28575 }
28576
28577 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28578 PyObject *resultobj = 0;
28579
28580 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 wxExit();
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 resultobj = SWIG_Py_Void();
28588 return resultobj;
28589 fail:
28590 return NULL;
28591 }
28592
28593
28594 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28595 PyObject *resultobj = 0;
28596 bool result;
28597
28598 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (bool)wxYield();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 bool result;
28617
28618 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = (bool)wxYieldIfNeeded();
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 {
28626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28627 }
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = 0;
28636 wxWindow *arg1 = (wxWindow *) NULL ;
28637 bool arg2 = (bool) false ;
28638 bool result;
28639 void *argp1 = 0 ;
28640 int res1 = 0 ;
28641 bool val2 ;
28642 int ecode2 = 0 ;
28643 PyObject * obj0 = 0 ;
28644 PyObject * obj1 = 0 ;
28645 char * kwnames[] = {
28646 (char *) "win",(char *) "onlyIfNeeded", NULL
28647 };
28648
28649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28650 if (obj0) {
28651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28652 if (!SWIG_IsOK(res1)) {
28653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28654 }
28655 arg1 = reinterpret_cast< wxWindow * >(argp1);
28656 }
28657 if (obj1) {
28658 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28659 if (!SWIG_IsOK(ecode2)) {
28660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28661 }
28662 arg2 = static_cast< bool >(val2);
28663 }
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 result = (bool)wxSafeYield(arg1,arg2);
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 {
28671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28672 }
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *resultobj = 0;
28681
28682 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 wxWakeUpIdle();
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 resultobj = SWIG_Py_Void();
28690 return resultobj;
28691 fail:
28692 return NULL;
28693 }
28694
28695
28696 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28697 PyObject *resultobj = 0;
28698 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28699 wxEvent *arg2 = 0 ;
28700 void *argp1 = 0 ;
28701 int res1 = 0 ;
28702 void *argp2 = 0 ;
28703 int res2 = 0 ;
28704 PyObject * obj0 = 0 ;
28705 PyObject * obj1 = 0 ;
28706 char * kwnames[] = {
28707 (char *) "dest",(char *) "event", NULL
28708 };
28709
28710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28712 if (!SWIG_IsOK(res1)) {
28713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28714 }
28715 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28717 if (!SWIG_IsOK(res2)) {
28718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28719 }
28720 if (!argp2) {
28721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28722 }
28723 arg2 = reinterpret_cast< wxEvent * >(argp2);
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 wxPostEvent(arg1,*arg2);
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_Py_Void();
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28738 PyObject *resultobj = 0;
28739
28740 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 wxApp_CleanUp();
28744 wxPyEndAllowThreads(__tstate);
28745 if (PyErr_Occurred()) SWIG_fail;
28746 }
28747 resultobj = SWIG_Py_Void();
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28755 PyObject *resultobj = 0;
28756 wxPyApp *result = 0 ;
28757
28758 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (wxPyApp *)wxPyGetApp();
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = wxPyMake_wxObject(result, 0);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj = 0;
28776 char *arg1 = (char *) 0 ;
28777 int res1 ;
28778 char *buf1 = 0 ;
28779 int alloc1 = 0 ;
28780 PyObject * obj0 = 0 ;
28781 char * kwnames[] = {
28782 (char *) "encoding", NULL
28783 };
28784
28785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28786 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28789 }
28790 arg1 = buf1;
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 wxSetDefaultPyEncoding((char const *)arg1);
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 resultobj = SWIG_Py_Void();
28798 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28799 return resultobj;
28800 fail:
28801 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 char *result = 0 ;
28809
28810 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (char *)wxGetDefaultPyEncoding();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_FromCharPtr(result);
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxEventLoop *result = 0 ;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (wxEventLoop *)new wxEventLoop();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 PyObject *resultobj = 0;
28844 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 PyObject *swig_obj[1] ;
28848
28849 if (!args) SWIG_fail;
28850 swig_obj[0] = args;
28851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28852 if (!SWIG_IsOK(res1)) {
28853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28854 }
28855 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 delete arg1;
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_Py_Void();
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28871 PyObject *resultobj = 0;
28872 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28873 int result;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 PyObject *swig_obj[1] ;
28877
28878 if (!args) SWIG_fail;
28879 swig_obj[0] = args;
28880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28881 if (!SWIG_IsOK(res1)) {
28882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28883 }
28884 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = (int)(arg1)->Run();
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 resultobj = SWIG_From_int(static_cast< int >(result));
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj = 0;
28900 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28901 int arg2 = (int) 0 ;
28902 void *argp1 = 0 ;
28903 int res1 = 0 ;
28904 int val2 ;
28905 int ecode2 = 0 ;
28906 PyObject * obj0 = 0 ;
28907 PyObject * obj1 = 0 ;
28908 char * kwnames[] = {
28909 (char *) "self",(char *) "rc", NULL
28910 };
28911
28912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28914 if (!SWIG_IsOK(res1)) {
28915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28916 }
28917 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28918 if (obj1) {
28919 ecode2 = SWIG_AsVal_int(obj1, &val2);
28920 if (!SWIG_IsOK(ecode2)) {
28921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28922 }
28923 arg2 = static_cast< int >(val2);
28924 }
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 (arg1)->Exit(arg2);
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = SWIG_Py_Void();
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28939 PyObject *resultobj = 0;
28940 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28941 bool result;
28942 void *argp1 = 0 ;
28943 int res1 = 0 ;
28944 PyObject *swig_obj[1] ;
28945
28946 if (!args) SWIG_fail;
28947 swig_obj[0] = args;
28948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28949 if (!SWIG_IsOK(res1)) {
28950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28951 }
28952 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 result = (bool)((wxEventLoop const *)arg1)->Pending();
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 {
28960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28961 }
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28969 PyObject *resultobj = 0;
28970 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28971 bool result;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 PyObject *swig_obj[1] ;
28975
28976 if (!args) SWIG_fail;
28977 swig_obj[0] = args;
28978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28981 }
28982 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (bool)(arg1)->Dispatch();
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 {
28990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28991 }
28992 return resultobj;
28993 fail:
28994 return NULL;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28999 PyObject *resultobj = 0;
29000 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29001 bool result;
29002 void *argp1 = 0 ;
29003 int res1 = 0 ;
29004 PyObject *swig_obj[1] ;
29005
29006 if (!args) SWIG_fail;
29007 swig_obj[0] = args;
29008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29009 if (!SWIG_IsOK(res1)) {
29010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29011 }
29012 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29013 {
29014 PyThreadState* __tstate = wxPyBeginAllowThreads();
29015 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 {
29020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29021 }
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29029 PyObject *resultobj = 0;
29030 wxEventLoop *result = 0 ;
29031
29032 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29033 {
29034 PyThreadState* __tstate = wxPyBeginAllowThreads();
29035 result = (wxEventLoop *)wxEventLoop::GetActive();
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj = 0;
29048 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29049 void *argp1 = 0 ;
29050 int res1 = 0 ;
29051 PyObject * obj0 = 0 ;
29052 char * kwnames[] = {
29053 (char *) "loop", NULL
29054 };
29055
29056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29058 if (!SWIG_IsOK(res1)) {
29059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29060 }
29061 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 wxEventLoop::SetActive(arg1);
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 resultobj = SWIG_Py_Void();
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 PyObject *obj;
29077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29078 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29079 return SWIG_Py_Void();
29080 }
29081
29082 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29083 return SWIG_Python_InitShadowInstance(args);
29084 }
29085
29086 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29087 PyObject *resultobj = 0;
29088 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29089 wxEventLoopActivator *result = 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 PyObject * obj0 = 0 ;
29093 char * kwnames[] = {
29094 (char *) "evtLoop", NULL
29095 };
29096
29097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29099 if (!SWIG_IsOK(res1)) {
29100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29101 }
29102 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29103 {
29104 PyThreadState* __tstate = wxPyBeginAllowThreads();
29105 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *resultobj = 0;
29118 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29119 void *argp1 = 0 ;
29120 int res1 = 0 ;
29121 PyObject *swig_obj[1] ;
29122
29123 if (!args) SWIG_fail;
29124 swig_obj[0] = args;
29125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29126 if (!SWIG_IsOK(res1)) {
29127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29128 }
29129 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 delete arg1;
29133
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_Py_Void();
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29145 PyObject *obj;
29146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29147 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29148 return SWIG_Py_Void();
29149 }
29150
29151 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 return SWIG_Python_InitShadowInstance(args);
29153 }
29154
29155 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29156 PyObject *resultobj = 0;
29157 int arg1 = (int) 0 ;
29158 int arg2 = (int) 0 ;
29159 int arg3 = (int) 0 ;
29160 wxAcceleratorEntry *result = 0 ;
29161 int val1 ;
29162 int ecode1 = 0 ;
29163 int val2 ;
29164 int ecode2 = 0 ;
29165 int val3 ;
29166 int ecode3 = 0 ;
29167 PyObject * obj0 = 0 ;
29168 PyObject * obj1 = 0 ;
29169 PyObject * obj2 = 0 ;
29170 char * kwnames[] = {
29171 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29172 };
29173
29174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29175 if (obj0) {
29176 ecode1 = SWIG_AsVal_int(obj0, &val1);
29177 if (!SWIG_IsOK(ecode1)) {
29178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29179 }
29180 arg1 = static_cast< int >(val1);
29181 }
29182 if (obj1) {
29183 ecode2 = SWIG_AsVal_int(obj1, &val2);
29184 if (!SWIG_IsOK(ecode2)) {
29185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29186 }
29187 arg2 = static_cast< int >(val2);
29188 }
29189 if (obj2) {
29190 ecode3 = SWIG_AsVal_int(obj2, &val3);
29191 if (!SWIG_IsOK(ecode3)) {
29192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29193 }
29194 arg3 = static_cast< int >(val3);
29195 }
29196 {
29197 PyThreadState* __tstate = wxPyBeginAllowThreads();
29198 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *resultobj = 0;
29211 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29212 void *argp1 = 0 ;
29213 int res1 = 0 ;
29214 PyObject *swig_obj[1] ;
29215
29216 if (!args) SWIG_fail;
29217 swig_obj[0] = args;
29218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29221 }
29222 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 delete arg1;
29226
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29238 PyObject *resultobj = 0;
29239 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29240 int arg2 ;
29241 int arg3 ;
29242 int arg4 ;
29243 void *argp1 = 0 ;
29244 int res1 = 0 ;
29245 int val2 ;
29246 int ecode2 = 0 ;
29247 int val3 ;
29248 int ecode3 = 0 ;
29249 int val4 ;
29250 int ecode4 = 0 ;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 PyObject * obj2 = 0 ;
29254 PyObject * obj3 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29263 }
29264 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29265 ecode2 = SWIG_AsVal_int(obj1, &val2);
29266 if (!SWIG_IsOK(ecode2)) {
29267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29268 }
29269 arg2 = static_cast< int >(val2);
29270 ecode3 = SWIG_AsVal_int(obj2, &val3);
29271 if (!SWIG_IsOK(ecode3)) {
29272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29273 }
29274 arg3 = static_cast< int >(val3);
29275 ecode4 = SWIG_AsVal_int(obj3, &val4);
29276 if (!SWIG_IsOK(ecode4)) {
29277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29278 }
29279 arg4 = static_cast< int >(val4);
29280 {
29281 PyThreadState* __tstate = wxPyBeginAllowThreads();
29282 (arg1)->Set(arg2,arg3,arg4);
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_Py_Void();
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29294 PyObject *resultobj = 0;
29295 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29296 int result;
29297 void *argp1 = 0 ;
29298 int res1 = 0 ;
29299 PyObject *swig_obj[1] ;
29300
29301 if (!args) SWIG_fail;
29302 swig_obj[0] = args;
29303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29306 }
29307 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29308 {
29309 PyThreadState* __tstate = wxPyBeginAllowThreads();
29310 result = (int)(arg1)->GetFlags();
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 resultobj = SWIG_From_int(static_cast< int >(result));
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29322 PyObject *resultobj = 0;
29323 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29324 int result;
29325 void *argp1 = 0 ;
29326 int res1 = 0 ;
29327 PyObject *swig_obj[1] ;
29328
29329 if (!args) SWIG_fail;
29330 swig_obj[0] = args;
29331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29332 if (!SWIG_IsOK(res1)) {
29333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29334 }
29335 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (int)(arg1)->GetKeyCode();
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 resultobj = SWIG_From_int(static_cast< int >(result));
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29350 PyObject *resultobj = 0;
29351 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29352 int result;
29353 void *argp1 = 0 ;
29354 int res1 = 0 ;
29355 PyObject *swig_obj[1] ;
29356
29357 if (!args) SWIG_fail;
29358 swig_obj[0] = args;
29359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29360 if (!SWIG_IsOK(res1)) {
29361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29362 }
29363 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = (int)(arg1)->GetCommand();
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_From_int(static_cast< int >(result));
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29378 PyObject *obj;
29379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29380 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29381 return SWIG_Py_Void();
29382 }
29383
29384 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29385 return SWIG_Python_InitShadowInstance(args);
29386 }
29387
29388 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj = 0;
29390 int arg1 ;
29391 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29392 wxAcceleratorTable *result = 0 ;
29393 PyObject * obj0 = 0 ;
29394 char * kwnames[] = {
29395 (char *) "n", NULL
29396 };
29397
29398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29399 {
29400 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29401 if (arg2) arg1 = PyList_Size(obj0);
29402 else arg1 = 0;
29403 }
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29407 wxPyEndAllowThreads(__tstate);
29408 if (PyErr_Occurred()) SWIG_fail;
29409 }
29410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29411 return resultobj;
29412 fail:
29413 return NULL;
29414 }
29415
29416
29417 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29418 PyObject *resultobj = 0;
29419 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29429 }
29430 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 delete arg1;
29434
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 resultobj = SWIG_Py_Void();
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29446 PyObject *resultobj = 0;
29447 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29448 bool result;
29449 void *argp1 = 0 ;
29450 int res1 = 0 ;
29451 PyObject *swig_obj[1] ;
29452
29453 if (!args) SWIG_fail;
29454 swig_obj[0] = args;
29455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29458 }
29459 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 {
29467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29468 }
29469 return resultobj;
29470 fail:
29471 return NULL;
29472 }
29473
29474
29475 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29476 PyObject *obj;
29477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29478 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29479 return SWIG_Py_Void();
29480 }
29481
29482 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29483 return SWIG_Python_InitShadowInstance(args);
29484 }
29485
29486 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29487 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29488 return 1;
29489 }
29490
29491
29492 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29493 PyObject *pyobj = 0;
29494
29495 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29496 return pyobj;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxString *arg1 = 0 ;
29503 wxAcceleratorEntry *result = 0 ;
29504 bool temp1 = false ;
29505 PyObject * obj0 = 0 ;
29506 char * kwnames[] = {
29507 (char *) "label", NULL
29508 };
29509
29510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29511 {
29512 arg1 = wxString_in_helper(obj0);
29513 if (arg1 == NULL) SWIG_fail;
29514 temp1 = true;
29515 }
29516 {
29517 PyThreadState* __tstate = wxPyBeginAllowThreads();
29518 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29523 {
29524 if (temp1)
29525 delete arg1;
29526 }
29527 return resultobj;
29528 fail:
29529 {
29530 if (temp1)
29531 delete arg1;
29532 }
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN int PanelNameStr_set(PyObject *) {
29538 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29539 return 1;
29540 }
29541
29542
29543 SWIGINTERN PyObject *PanelNameStr_get(void) {
29544 PyObject *pyobj = 0;
29545
29546 {
29547 #if wxUSE_UNICODE
29548 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29549 #else
29550 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29551 #endif
29552 }
29553 return pyobj;
29554 }
29555
29556
29557 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29558 PyObject *resultobj = 0;
29559 wxVisualAttributes *result = 0 ;
29560
29561 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29562 {
29563 PyThreadState* __tstate = wxPyBeginAllowThreads();
29564 result = (wxVisualAttributes *)new_wxVisualAttributes();
29565 wxPyEndAllowThreads(__tstate);
29566 if (PyErr_Occurred()) SWIG_fail;
29567 }
29568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29569 return resultobj;
29570 fail:
29571 return NULL;
29572 }
29573
29574
29575 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29576 PyObject *resultobj = 0;
29577 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29578 void *argp1 = 0 ;
29579 int res1 = 0 ;
29580 PyObject *swig_obj[1] ;
29581
29582 if (!args) SWIG_fail;
29583 swig_obj[0] = args;
29584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29585 if (!SWIG_IsOK(res1)) {
29586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29587 }
29588 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29589 {
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 delete_wxVisualAttributes(arg1);
29592
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 resultobj = SWIG_Py_Void();
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 PyObject *resultobj = 0;
29605 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29606 wxFont *arg2 = (wxFont *) 0 ;
29607 void *argp1 = 0 ;
29608 int res1 = 0 ;
29609 void *argp2 = 0 ;
29610 int res2 = 0 ;
29611 PyObject *swig_obj[2] ;
29612
29613 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29617 }
29618 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29619 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29620 if (!SWIG_IsOK(res2)) {
29621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29622 }
29623 arg2 = reinterpret_cast< wxFont * >(argp2);
29624 if (arg1) (arg1)->font = *arg2;
29625
29626 resultobj = SWIG_Py_Void();
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29634 PyObject *resultobj = 0;
29635 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29636 wxFont *result = 0 ;
29637 void *argp1 = 0 ;
29638 int res1 = 0 ;
29639 PyObject *swig_obj[1] ;
29640
29641 if (!args) SWIG_fail;
29642 swig_obj[0] = args;
29643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29646 }
29647 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29648 result = (wxFont *)& ((arg1)->font);
29649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29657 PyObject *resultobj = 0;
29658 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29659 wxColour *arg2 = (wxColour *) 0 ;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 void *argp2 = 0 ;
29663 int res2 = 0 ;
29664 PyObject *swig_obj[2] ;
29665
29666 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29668 if (!SWIG_IsOK(res1)) {
29669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29670 }
29671 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29672 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29673 if (!SWIG_IsOK(res2)) {
29674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29675 }
29676 arg2 = reinterpret_cast< wxColour * >(argp2);
29677 if (arg1) (arg1)->colFg = *arg2;
29678
29679 resultobj = SWIG_Py_Void();
29680 return resultobj;
29681 fail:
29682 return NULL;
29683 }
29684
29685
29686 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29687 PyObject *resultobj = 0;
29688 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29689 wxColour *result = 0 ;
29690 void *argp1 = 0 ;
29691 int res1 = 0 ;
29692 PyObject *swig_obj[1] ;
29693
29694 if (!args) SWIG_fail;
29695 swig_obj[0] = args;
29696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29697 if (!SWIG_IsOK(res1)) {
29698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29699 }
29700 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29701 result = (wxColour *)& ((arg1)->colFg);
29702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29710 PyObject *resultobj = 0;
29711 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29712 wxColour *arg2 = (wxColour *) 0 ;
29713 void *argp1 = 0 ;
29714 int res1 = 0 ;
29715 void *argp2 = 0 ;
29716 int res2 = 0 ;
29717 PyObject *swig_obj[2] ;
29718
29719 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29721 if (!SWIG_IsOK(res1)) {
29722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29723 }
29724 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29726 if (!SWIG_IsOK(res2)) {
29727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29728 }
29729 arg2 = reinterpret_cast< wxColour * >(argp2);
29730 if (arg1) (arg1)->colBg = *arg2;
29731
29732 resultobj = SWIG_Py_Void();
29733 return resultobj;
29734 fail:
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29740 PyObject *resultobj = 0;
29741 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29742 wxColour *result = 0 ;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 PyObject *swig_obj[1] ;
29746
29747 if (!args) SWIG_fail;
29748 swig_obj[0] = args;
29749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29750 if (!SWIG_IsOK(res1)) {
29751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29752 }
29753 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29754 result = (wxColour *)& ((arg1)->colBg);
29755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29756 return resultobj;
29757 fail:
29758 return NULL;
29759 }
29760
29761
29762 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29763 PyObject *obj;
29764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29765 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29766 return SWIG_Py_Void();
29767 }
29768
29769 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29770 return SWIG_Python_InitShadowInstance(args);
29771 }
29772
29773 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj = 0;
29775 wxWindow *arg1 = (wxWindow *) 0 ;
29776 int arg2 = (int) (int)-1 ;
29777 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29778 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29779 wxSize const &arg4_defvalue = wxDefaultSize ;
29780 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29781 long arg5 = (long) 0 ;
29782 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29783 wxString *arg6 = (wxString *) &arg6_defvalue ;
29784 wxWindow *result = 0 ;
29785 void *argp1 = 0 ;
29786 int res1 = 0 ;
29787 int val2 ;
29788 int ecode2 = 0 ;
29789 wxPoint temp3 ;
29790 wxSize temp4 ;
29791 long val5 ;
29792 int ecode5 = 0 ;
29793 bool temp6 = false ;
29794 PyObject * obj0 = 0 ;
29795 PyObject * obj1 = 0 ;
29796 PyObject * obj2 = 0 ;
29797 PyObject * obj3 = 0 ;
29798 PyObject * obj4 = 0 ;
29799 PyObject * obj5 = 0 ;
29800 char * kwnames[] = {
29801 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29802 };
29803
29804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29806 if (!SWIG_IsOK(res1)) {
29807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29808 }
29809 arg1 = reinterpret_cast< wxWindow * >(argp1);
29810 if (obj1) {
29811 ecode2 = SWIG_AsVal_int(obj1, &val2);
29812 if (!SWIG_IsOK(ecode2)) {
29813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29814 }
29815 arg2 = static_cast< int >(val2);
29816 }
29817 if (obj2) {
29818 {
29819 arg3 = &temp3;
29820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29821 }
29822 }
29823 if (obj3) {
29824 {
29825 arg4 = &temp4;
29826 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29827 }
29828 }
29829 if (obj4) {
29830 ecode5 = SWIG_AsVal_long(obj4, &val5);
29831 if (!SWIG_IsOK(ecode5)) {
29832 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29833 }
29834 arg5 = static_cast< long >(val5);
29835 }
29836 if (obj5) {
29837 {
29838 arg6 = wxString_in_helper(obj5);
29839 if (arg6 == NULL) SWIG_fail;
29840 temp6 = true;
29841 }
29842 }
29843 {
29844 if (!wxPyCheckForApp()) SWIG_fail;
29845 PyThreadState* __tstate = wxPyBeginAllowThreads();
29846 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29847 wxPyEndAllowThreads(__tstate);
29848 if (PyErr_Occurred()) SWIG_fail;
29849 }
29850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29851 {
29852 if (temp6)
29853 delete arg6;
29854 }
29855 return resultobj;
29856 fail:
29857 {
29858 if (temp6)
29859 delete arg6;
29860 }
29861 return NULL;
29862 }
29863
29864
29865 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29866 PyObject *resultobj = 0;
29867 wxWindow *result = 0 ;
29868
29869 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29870 {
29871 if (!wxPyCheckForApp()) SWIG_fail;
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (wxWindow *)new wxWindow();
29874 wxPyEndAllowThreads(__tstate);
29875 if (PyErr_Occurred()) SWIG_fail;
29876 }
29877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29885 PyObject *resultobj = 0;
29886 wxWindow *arg1 = (wxWindow *) 0 ;
29887 wxWindow *arg2 = (wxWindow *) 0 ;
29888 int arg3 = (int) (int)-1 ;
29889 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29890 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29891 wxSize const &arg5_defvalue = wxDefaultSize ;
29892 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29893 long arg6 = (long) 0 ;
29894 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29895 wxString *arg7 = (wxString *) &arg7_defvalue ;
29896 bool result;
29897 void *argp1 = 0 ;
29898 int res1 = 0 ;
29899 void *argp2 = 0 ;
29900 int res2 = 0 ;
29901 int val3 ;
29902 int ecode3 = 0 ;
29903 wxPoint temp4 ;
29904 wxSize temp5 ;
29905 long val6 ;
29906 int ecode6 = 0 ;
29907 bool temp7 = false ;
29908 PyObject * obj0 = 0 ;
29909 PyObject * obj1 = 0 ;
29910 PyObject * obj2 = 0 ;
29911 PyObject * obj3 = 0 ;
29912 PyObject * obj4 = 0 ;
29913 PyObject * obj5 = 0 ;
29914 PyObject * obj6 = 0 ;
29915 char * kwnames[] = {
29916 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29917 };
29918
29919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29921 if (!SWIG_IsOK(res1)) {
29922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29923 }
29924 arg1 = reinterpret_cast< wxWindow * >(argp1);
29925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29926 if (!SWIG_IsOK(res2)) {
29927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29928 }
29929 arg2 = reinterpret_cast< wxWindow * >(argp2);
29930 if (obj2) {
29931 ecode3 = SWIG_AsVal_int(obj2, &val3);
29932 if (!SWIG_IsOK(ecode3)) {
29933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29934 }
29935 arg3 = static_cast< int >(val3);
29936 }
29937 if (obj3) {
29938 {
29939 arg4 = &temp4;
29940 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29941 }
29942 }
29943 if (obj4) {
29944 {
29945 arg5 = &temp5;
29946 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29947 }
29948 }
29949 if (obj5) {
29950 ecode6 = SWIG_AsVal_long(obj5, &val6);
29951 if (!SWIG_IsOK(ecode6)) {
29952 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29953 }
29954 arg6 = static_cast< long >(val6);
29955 }
29956 if (obj6) {
29957 {
29958 arg7 = wxString_in_helper(obj6);
29959 if (arg7 == NULL) SWIG_fail;
29960 temp7 = true;
29961 }
29962 }
29963 {
29964 PyThreadState* __tstate = wxPyBeginAllowThreads();
29965 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29966 wxPyEndAllowThreads(__tstate);
29967 if (PyErr_Occurred()) SWIG_fail;
29968 }
29969 {
29970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29971 }
29972 {
29973 if (temp7)
29974 delete arg7;
29975 }
29976 return resultobj;
29977 fail:
29978 {
29979 if (temp7)
29980 delete arg7;
29981 }
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj = 0;
29988 wxWindow *arg1 = (wxWindow *) 0 ;
29989 bool arg2 = (bool) false ;
29990 bool result;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 bool val2 ;
29994 int ecode2 = 0 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 char * kwnames[] = {
29998 (char *) "self",(char *) "force", NULL
29999 };
30000
30001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30005 }
30006 arg1 = reinterpret_cast< wxWindow * >(argp1);
30007 if (obj1) {
30008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30009 if (!SWIG_IsOK(ecode2)) {
30010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30011 }
30012 arg2 = static_cast< bool >(val2);
30013 }
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = (bool)(arg1)->Close(arg2);
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30022 }
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30030 PyObject *resultobj = 0;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 bool result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 PyObject *swig_obj[1] ;
30036
30037 if (!args) SWIG_fail;
30038 swig_obj[0] = args;
30039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30040 if (!SWIG_IsOK(res1)) {
30041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30042 }
30043 arg1 = reinterpret_cast< wxWindow * >(argp1);
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (bool)(arg1)->Destroy();
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 {
30051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30052 }
30053 return resultobj;
30054 fail:
30055 return NULL;
30056 }
30057
30058
30059 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30060 PyObject *resultobj = 0;
30061 wxWindow *arg1 = (wxWindow *) 0 ;
30062 bool result;
30063 void *argp1 = 0 ;
30064 int res1 = 0 ;
30065 PyObject *swig_obj[1] ;
30066
30067 if (!args) SWIG_fail;
30068 swig_obj[0] = args;
30069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30070 if (!SWIG_IsOK(res1)) {
30071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30072 }
30073 arg1 = reinterpret_cast< wxWindow * >(argp1);
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 result = (bool)(arg1)->DestroyChildren();
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 {
30081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30082 }
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30090 PyObject *resultobj = 0;
30091 wxWindow *arg1 = (wxWindow *) 0 ;
30092 bool result;
30093 void *argp1 = 0 ;
30094 int res1 = 0 ;
30095 PyObject *swig_obj[1] ;
30096
30097 if (!args) SWIG_fail;
30098 swig_obj[0] = args;
30099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30100 if (!SWIG_IsOK(res1)) {
30101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30102 }
30103 arg1 = reinterpret_cast< wxWindow * >(argp1);
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 {
30111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30112 }
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = 0;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 wxString *arg2 = 0 ;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 bool temp2 = false ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char * kwnames[] = {
30129 (char *) "self",(char *) "label", NULL
30130 };
30131
30132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30134 if (!SWIG_IsOK(res1)) {
30135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30136 }
30137 arg1 = reinterpret_cast< wxWindow * >(argp1);
30138 {
30139 arg2 = wxString_in_helper(obj1);
30140 if (arg2 == NULL) SWIG_fail;
30141 temp2 = true;
30142 }
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 (arg1)->SetLabel((wxString const &)*arg2);
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 resultobj = SWIG_Py_Void();
30150 {
30151 if (temp2)
30152 delete arg2;
30153 }
30154 return resultobj;
30155 fail:
30156 {
30157 if (temp2)
30158 delete arg2;
30159 }
30160 return NULL;
30161 }
30162
30163
30164 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30165 PyObject *resultobj = 0;
30166 wxWindow *arg1 = (wxWindow *) 0 ;
30167 wxString result;
30168 void *argp1 = 0 ;
30169 int res1 = 0 ;
30170 PyObject *swig_obj[1] ;
30171
30172 if (!args) SWIG_fail;
30173 swig_obj[0] = args;
30174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30175 if (!SWIG_IsOK(res1)) {
30176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30177 }
30178 arg1 = reinterpret_cast< wxWindow * >(argp1);
30179 {
30180 PyThreadState* __tstate = wxPyBeginAllowThreads();
30181 result = ((wxWindow const *)arg1)->GetLabel();
30182 wxPyEndAllowThreads(__tstate);
30183 if (PyErr_Occurred()) SWIG_fail;
30184 }
30185 {
30186 #if wxUSE_UNICODE
30187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30188 #else
30189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30190 #endif
30191 }
30192 return resultobj;
30193 fail:
30194 return NULL;
30195 }
30196
30197
30198 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30199 PyObject *resultobj = 0;
30200 wxWindow *arg1 = (wxWindow *) 0 ;
30201 wxString *arg2 = 0 ;
30202 void *argp1 = 0 ;
30203 int res1 = 0 ;
30204 bool temp2 = false ;
30205 PyObject * obj0 = 0 ;
30206 PyObject * obj1 = 0 ;
30207 char * kwnames[] = {
30208 (char *) "self",(char *) "name", NULL
30209 };
30210
30211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30213 if (!SWIG_IsOK(res1)) {
30214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30215 }
30216 arg1 = reinterpret_cast< wxWindow * >(argp1);
30217 {
30218 arg2 = wxString_in_helper(obj1);
30219 if (arg2 == NULL) SWIG_fail;
30220 temp2 = true;
30221 }
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 (arg1)->SetName((wxString const &)*arg2);
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 resultobj = SWIG_Py_Void();
30229 {
30230 if (temp2)
30231 delete arg2;
30232 }
30233 return resultobj;
30234 fail:
30235 {
30236 if (temp2)
30237 delete arg2;
30238 }
30239 return NULL;
30240 }
30241
30242
30243 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30244 PyObject *resultobj = 0;
30245 wxWindow *arg1 = (wxWindow *) 0 ;
30246 wxString result;
30247 void *argp1 = 0 ;
30248 int res1 = 0 ;
30249 PyObject *swig_obj[1] ;
30250
30251 if (!args) SWIG_fail;
30252 swig_obj[0] = args;
30253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30254 if (!SWIG_IsOK(res1)) {
30255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30256 }
30257 arg1 = reinterpret_cast< wxWindow * >(argp1);
30258 {
30259 PyThreadState* __tstate = wxPyBeginAllowThreads();
30260 result = ((wxWindow const *)arg1)->GetName();
30261 wxPyEndAllowThreads(__tstate);
30262 if (PyErr_Occurred()) SWIG_fail;
30263 }
30264 {
30265 #if wxUSE_UNICODE
30266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30267 #else
30268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30269 #endif
30270 }
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = 0;
30279 wxWindow *arg1 = (wxWindow *) 0 ;
30280 wxWindowVariant arg2 ;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 int val2 ;
30284 int ecode2 = 0 ;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 char * kwnames[] = {
30288 (char *) "self",(char *) "variant", NULL
30289 };
30290
30291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30293 if (!SWIG_IsOK(res1)) {
30294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30295 }
30296 arg1 = reinterpret_cast< wxWindow * >(argp1);
30297 ecode2 = SWIG_AsVal_int(obj1, &val2);
30298 if (!SWIG_IsOK(ecode2)) {
30299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30300 }
30301 arg2 = static_cast< wxWindowVariant >(val2);
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 (arg1)->SetWindowVariant(arg2);
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 resultobj = SWIG_Py_Void();
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30316 PyObject *resultobj = 0;
30317 wxWindow *arg1 = (wxWindow *) 0 ;
30318 wxWindowVariant result;
30319 void *argp1 = 0 ;
30320 int res1 = 0 ;
30321 PyObject *swig_obj[1] ;
30322
30323 if (!args) SWIG_fail;
30324 swig_obj[0] = args;
30325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30326 if (!SWIG_IsOK(res1)) {
30327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30328 }
30329 arg1 = reinterpret_cast< wxWindow * >(argp1);
30330 {
30331 PyThreadState* __tstate = wxPyBeginAllowThreads();
30332 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 resultobj = SWIG_From_int(static_cast< int >(result));
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj = 0;
30345 wxWindow *arg1 = (wxWindow *) 0 ;
30346 int arg2 ;
30347 void *argp1 = 0 ;
30348 int res1 = 0 ;
30349 int val2 ;
30350 int ecode2 = 0 ;
30351 PyObject * obj0 = 0 ;
30352 PyObject * obj1 = 0 ;
30353 char * kwnames[] = {
30354 (char *) "self",(char *) "winid", NULL
30355 };
30356
30357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30359 if (!SWIG_IsOK(res1)) {
30360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30361 }
30362 arg1 = reinterpret_cast< wxWindow * >(argp1);
30363 ecode2 = SWIG_AsVal_int(obj1, &val2);
30364 if (!SWIG_IsOK(ecode2)) {
30365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30366 }
30367 arg2 = static_cast< int >(val2);
30368 {
30369 PyThreadState* __tstate = wxPyBeginAllowThreads();
30370 (arg1)->SetId(arg2);
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 resultobj = SWIG_Py_Void();
30375 return resultobj;
30376 fail:
30377 return NULL;
30378 }
30379
30380
30381 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30382 PyObject *resultobj = 0;
30383 wxWindow *arg1 = (wxWindow *) 0 ;
30384 int result;
30385 void *argp1 = 0 ;
30386 int res1 = 0 ;
30387 PyObject *swig_obj[1] ;
30388
30389 if (!args) SWIG_fail;
30390 swig_obj[0] = args;
30391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30392 if (!SWIG_IsOK(res1)) {
30393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30394 }
30395 arg1 = reinterpret_cast< wxWindow * >(argp1);
30396 {
30397 PyThreadState* __tstate = wxPyBeginAllowThreads();
30398 result = (int)((wxWindow const *)arg1)->GetId();
30399 wxPyEndAllowThreads(__tstate);
30400 if (PyErr_Occurred()) SWIG_fail;
30401 }
30402 resultobj = SWIG_From_int(static_cast< int >(result));
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30410 PyObject *resultobj = 0;
30411 int result;
30412
30413 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = (int)wxWindow::NewControlId();
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_From_int(static_cast< int >(result));
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 int arg1 ;
30430 int result;
30431 int val1 ;
30432 int ecode1 = 0 ;
30433 PyObject * obj0 = 0 ;
30434 char * kwnames[] = {
30435 (char *) "winid", NULL
30436 };
30437
30438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30439 ecode1 = SWIG_AsVal_int(obj0, &val1);
30440 if (!SWIG_IsOK(ecode1)) {
30441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30442 }
30443 arg1 = static_cast< int >(val1);
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = (int)wxWindow::NextControlId(arg1);
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_From_int(static_cast< int >(result));
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj = 0;
30459 int arg1 ;
30460 int result;
30461 int val1 ;
30462 int ecode1 = 0 ;
30463 PyObject * obj0 = 0 ;
30464 char * kwnames[] = {
30465 (char *) "winid", NULL
30466 };
30467
30468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30469 ecode1 = SWIG_AsVal_int(obj0, &val1);
30470 if (!SWIG_IsOK(ecode1)) {
30471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30472 }
30473 arg1 = static_cast< int >(val1);
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 result = (int)wxWindow::PrevControlId(arg1);
30477 wxPyEndAllowThreads(__tstate);
30478 if (PyErr_Occurred()) SWIG_fail;
30479 }
30480 resultobj = SWIG_From_int(static_cast< int >(result));
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 wxSize *arg2 = 0 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 wxSize temp2 ;
30494 PyObject * obj0 = 0 ;
30495 PyObject * obj1 = 0 ;
30496 char * kwnames[] = {
30497 (char *) "self",(char *) "size", NULL
30498 };
30499
30500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30504 }
30505 arg1 = reinterpret_cast< wxWindow * >(argp1);
30506 {
30507 arg2 = &temp2;
30508 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30509 }
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 (arg1)->SetSize((wxSize const &)*arg2);
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 resultobj = SWIG_Py_Void();
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30524 PyObject *resultobj = 0;
30525 wxWindow *arg1 = (wxWindow *) 0 ;
30526 int arg2 ;
30527 int arg3 ;
30528 int arg4 ;
30529 int arg5 ;
30530 int arg6 = (int) wxSIZE_AUTO ;
30531 void *argp1 = 0 ;
30532 int res1 = 0 ;
30533 int val2 ;
30534 int ecode2 = 0 ;
30535 int val3 ;
30536 int ecode3 = 0 ;
30537 int val4 ;
30538 int ecode4 = 0 ;
30539 int val5 ;
30540 int ecode5 = 0 ;
30541 int val6 ;
30542 int ecode6 = 0 ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 PyObject * obj2 = 0 ;
30546 PyObject * obj3 = 0 ;
30547 PyObject * obj4 = 0 ;
30548 PyObject * obj5 = 0 ;
30549 char * kwnames[] = {
30550 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30551 };
30552
30553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30555 if (!SWIG_IsOK(res1)) {
30556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30557 }
30558 arg1 = reinterpret_cast< wxWindow * >(argp1);
30559 ecode2 = SWIG_AsVal_int(obj1, &val2);
30560 if (!SWIG_IsOK(ecode2)) {
30561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30562 }
30563 arg2 = static_cast< int >(val2);
30564 ecode3 = SWIG_AsVal_int(obj2, &val3);
30565 if (!SWIG_IsOK(ecode3)) {
30566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30567 }
30568 arg3 = static_cast< int >(val3);
30569 ecode4 = SWIG_AsVal_int(obj3, &val4);
30570 if (!SWIG_IsOK(ecode4)) {
30571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30572 }
30573 arg4 = static_cast< int >(val4);
30574 ecode5 = SWIG_AsVal_int(obj4, &val5);
30575 if (!SWIG_IsOK(ecode5)) {
30576 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30577 }
30578 arg5 = static_cast< int >(val5);
30579 if (obj5) {
30580 ecode6 = SWIG_AsVal_int(obj5, &val6);
30581 if (!SWIG_IsOK(ecode6)) {
30582 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30583 }
30584 arg6 = static_cast< int >(val6);
30585 }
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 resultobj = SWIG_Py_Void();
30593 return resultobj;
30594 fail:
30595 return NULL;
30596 }
30597
30598
30599 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30600 PyObject *resultobj = 0;
30601 wxWindow *arg1 = (wxWindow *) 0 ;
30602 wxRect *arg2 = 0 ;
30603 int arg3 = (int) wxSIZE_AUTO ;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 wxRect temp2 ;
30607 int val3 ;
30608 int ecode3 = 0 ;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611 PyObject * obj2 = 0 ;
30612 char * kwnames[] = {
30613 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30614 };
30615
30616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30618 if (!SWIG_IsOK(res1)) {
30619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30620 }
30621 arg1 = reinterpret_cast< wxWindow * >(argp1);
30622 {
30623 arg2 = &temp2;
30624 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30625 }
30626 if (obj2) {
30627 ecode3 = SWIG_AsVal_int(obj2, &val3);
30628 if (!SWIG_IsOK(ecode3)) {
30629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30630 }
30631 arg3 = static_cast< int >(val3);
30632 }
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_Py_Void();
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj = 0;
30648 wxWindow *arg1 = (wxWindow *) 0 ;
30649 int arg2 ;
30650 int arg3 ;
30651 void *argp1 = 0 ;
30652 int res1 = 0 ;
30653 int val2 ;
30654 int ecode2 = 0 ;
30655 int val3 ;
30656 int ecode3 = 0 ;
30657 PyObject * obj0 = 0 ;
30658 PyObject * obj1 = 0 ;
30659 PyObject * obj2 = 0 ;
30660 char * kwnames[] = {
30661 (char *) "self",(char *) "width",(char *) "height", NULL
30662 };
30663
30664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30666 if (!SWIG_IsOK(res1)) {
30667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30668 }
30669 arg1 = reinterpret_cast< wxWindow * >(argp1);
30670 ecode2 = SWIG_AsVal_int(obj1, &val2);
30671 if (!SWIG_IsOK(ecode2)) {
30672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30673 }
30674 arg2 = static_cast< int >(val2);
30675 ecode3 = SWIG_AsVal_int(obj2, &val3);
30676 if (!SWIG_IsOK(ecode3)) {
30677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30678 }
30679 arg3 = static_cast< int >(val3);
30680 {
30681 PyThreadState* __tstate = wxPyBeginAllowThreads();
30682 (arg1)->SetSize(arg2,arg3);
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 resultobj = SWIG_Py_Void();
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj = 0;
30695 wxWindow *arg1 = (wxWindow *) 0 ;
30696 wxPoint *arg2 = 0 ;
30697 int arg3 = (int) wxSIZE_USE_EXISTING ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 wxPoint temp2 ;
30701 int val3 ;
30702 int ecode3 = 0 ;
30703 PyObject * obj0 = 0 ;
30704 PyObject * obj1 = 0 ;
30705 PyObject * obj2 = 0 ;
30706 char * kwnames[] = {
30707 (char *) "self",(char *) "pt",(char *) "flags", NULL
30708 };
30709
30710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30712 if (!SWIG_IsOK(res1)) {
30713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30714 }
30715 arg1 = reinterpret_cast< wxWindow * >(argp1);
30716 {
30717 arg2 = &temp2;
30718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30719 }
30720 if (obj2) {
30721 ecode3 = SWIG_AsVal_int(obj2, &val3);
30722 if (!SWIG_IsOK(ecode3)) {
30723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30724 }
30725 arg3 = static_cast< int >(val3);
30726 }
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 (arg1)->Move((wxPoint const &)*arg2,arg3);
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 resultobj = SWIG_Py_Void();
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30741 PyObject *resultobj = 0;
30742 wxWindow *arg1 = (wxWindow *) 0 ;
30743 int arg2 ;
30744 int arg3 ;
30745 int arg4 = (int) wxSIZE_USE_EXISTING ;
30746 void *argp1 = 0 ;
30747 int res1 = 0 ;
30748 int val2 ;
30749 int ecode2 = 0 ;
30750 int val3 ;
30751 int ecode3 = 0 ;
30752 int val4 ;
30753 int ecode4 = 0 ;
30754 PyObject * obj0 = 0 ;
30755 PyObject * obj1 = 0 ;
30756 PyObject * obj2 = 0 ;
30757 PyObject * obj3 = 0 ;
30758 char * kwnames[] = {
30759 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30760 };
30761
30762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30764 if (!SWIG_IsOK(res1)) {
30765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30766 }
30767 arg1 = reinterpret_cast< wxWindow * >(argp1);
30768 ecode2 = SWIG_AsVal_int(obj1, &val2);
30769 if (!SWIG_IsOK(ecode2)) {
30770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30771 }
30772 arg2 = static_cast< int >(val2);
30773 ecode3 = SWIG_AsVal_int(obj2, &val3);
30774 if (!SWIG_IsOK(ecode3)) {
30775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30776 }
30777 arg3 = static_cast< int >(val3);
30778 if (obj3) {
30779 ecode4 = SWIG_AsVal_int(obj3, &val4);
30780 if (!SWIG_IsOK(ecode4)) {
30781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30782 }
30783 arg4 = static_cast< int >(val4);
30784 }
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 (arg1)->Move(arg2,arg3,arg4);
30788 wxPyEndAllowThreads(__tstate);
30789 if (PyErr_Occurred()) SWIG_fail;
30790 }
30791 resultobj = SWIG_Py_Void();
30792 return resultobj;
30793 fail:
30794 return NULL;
30795 }
30796
30797
30798 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30799 PyObject *resultobj = 0;
30800 wxWindow *arg1 = (wxWindow *) 0 ;
30801 wxSize const &arg2_defvalue = wxDefaultSize ;
30802 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 wxSize temp2 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 char * kwnames[] = {
30809 (char *) "self",(char *) "size", NULL
30810 };
30811
30812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30814 if (!SWIG_IsOK(res1)) {
30815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30816 }
30817 arg1 = reinterpret_cast< wxWindow * >(argp1);
30818 if (obj1) {
30819 {
30820 arg2 = &temp2;
30821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30822 }
30823 }
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_Py_Void();
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30838 PyObject *resultobj = 0;
30839 wxWindow *arg1 = (wxWindow *) 0 ;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 PyObject *swig_obj[1] ;
30843
30844 if (!args) SWIG_fail;
30845 swig_obj[0] = args;
30846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30847 if (!SWIG_IsOK(res1)) {
30848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30849 }
30850 arg1 = reinterpret_cast< wxWindow * >(argp1);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 (arg1)->Raise();
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_Py_Void();
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 PyObject *swig_obj[1] ;
30870
30871 if (!args) SWIG_fail;
30872 swig_obj[0] = args;
30873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30874 if (!SWIG_IsOK(res1)) {
30875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30876 }
30877 arg1 = reinterpret_cast< wxWindow * >(argp1);
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 (arg1)->Lower();
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 resultobj = SWIG_Py_Void();
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj = 0;
30893 wxWindow *arg1 = (wxWindow *) 0 ;
30894 wxSize *arg2 = 0 ;
30895 void *argp1 = 0 ;
30896 int res1 = 0 ;
30897 wxSize temp2 ;
30898 PyObject * obj0 = 0 ;
30899 PyObject * obj1 = 0 ;
30900 char * kwnames[] = {
30901 (char *) "self",(char *) "size", NULL
30902 };
30903
30904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30906 if (!SWIG_IsOK(res1)) {
30907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30908 }
30909 arg1 = reinterpret_cast< wxWindow * >(argp1);
30910 {
30911 arg2 = &temp2;
30912 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30913 }
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 (arg1)->SetClientSize((wxSize const &)*arg2);
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 resultobj = SWIG_Py_Void();
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj = 0;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 int arg2 ;
30931 int arg3 ;
30932 void *argp1 = 0 ;
30933 int res1 = 0 ;
30934 int val2 ;
30935 int ecode2 = 0 ;
30936 int val3 ;
30937 int ecode3 = 0 ;
30938 PyObject * obj0 = 0 ;
30939 PyObject * obj1 = 0 ;
30940 PyObject * obj2 = 0 ;
30941 char * kwnames[] = {
30942 (char *) "self",(char *) "width",(char *) "height", NULL
30943 };
30944
30945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30947 if (!SWIG_IsOK(res1)) {
30948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30949 }
30950 arg1 = reinterpret_cast< wxWindow * >(argp1);
30951 ecode2 = SWIG_AsVal_int(obj1, &val2);
30952 if (!SWIG_IsOK(ecode2)) {
30953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30954 }
30955 arg2 = static_cast< int >(val2);
30956 ecode3 = SWIG_AsVal_int(obj2, &val3);
30957 if (!SWIG_IsOK(ecode3)) {
30958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30959 }
30960 arg3 = static_cast< int >(val3);
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 (arg1)->SetClientSize(arg2,arg3);
30964 wxPyEndAllowThreads(__tstate);
30965 if (PyErr_Occurred()) SWIG_fail;
30966 }
30967 resultobj = SWIG_Py_Void();
30968 return resultobj;
30969 fail:
30970 return NULL;
30971 }
30972
30973
30974 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30975 PyObject *resultobj = 0;
30976 wxWindow *arg1 = (wxWindow *) 0 ;
30977 wxRect *arg2 = 0 ;
30978 void *argp1 = 0 ;
30979 int res1 = 0 ;
30980 wxRect temp2 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 char * kwnames[] = {
30984 (char *) "self",(char *) "rect", NULL
30985 };
30986
30987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30991 }
30992 arg1 = reinterpret_cast< wxWindow * >(argp1);
30993 {
30994 arg2 = &temp2;
30995 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30996 }
30997 {
30998 PyThreadState* __tstate = wxPyBeginAllowThreads();
30999 (arg1)->SetClientSize((wxRect const &)*arg2);
31000 wxPyEndAllowThreads(__tstate);
31001 if (PyErr_Occurred()) SWIG_fail;
31002 }
31003 resultobj = SWIG_Py_Void();
31004 return resultobj;
31005 fail:
31006 return NULL;
31007 }
31008
31009
31010 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31011 PyObject *resultobj = 0;
31012 wxWindow *arg1 = (wxWindow *) 0 ;
31013 wxPoint result;
31014 void *argp1 = 0 ;
31015 int res1 = 0 ;
31016 PyObject *swig_obj[1] ;
31017
31018 if (!args) SWIG_fail;
31019 swig_obj[0] = args;
31020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31021 if (!SWIG_IsOK(res1)) {
31022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31023 }
31024 arg1 = reinterpret_cast< wxWindow * >(argp1);
31025 {
31026 PyThreadState* __tstate = wxPyBeginAllowThreads();
31027 result = ((wxWindow const *)arg1)->GetPosition();
31028 wxPyEndAllowThreads(__tstate);
31029 if (PyErr_Occurred()) SWIG_fail;
31030 }
31031 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31032 return resultobj;
31033 fail:
31034 return NULL;
31035 }
31036
31037
31038 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31039 PyObject *resultobj = 0;
31040 wxWindow *arg1 = (wxWindow *) 0 ;
31041 int *arg2 = (int *) 0 ;
31042 int *arg3 = (int *) 0 ;
31043 void *argp1 = 0 ;
31044 int res1 = 0 ;
31045 int temp2 ;
31046 int res2 = SWIG_TMPOBJ ;
31047 int temp3 ;
31048 int res3 = SWIG_TMPOBJ ;
31049 PyObject *swig_obj[1] ;
31050
31051 arg2 = &temp2;
31052 arg3 = &temp3;
31053 if (!args) SWIG_fail;
31054 swig_obj[0] = args;
31055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31056 if (!SWIG_IsOK(res1)) {
31057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31058 }
31059 arg1 = reinterpret_cast< wxWindow * >(argp1);
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_Py_Void();
31067 if (SWIG_IsTmpObj(res2)) {
31068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31069 } else {
31070 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31072 }
31073 if (SWIG_IsTmpObj(res3)) {
31074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31075 } else {
31076 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31078 }
31079 return resultobj;
31080 fail:
31081 return NULL;
31082 }
31083
31084
31085 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31086 PyObject *resultobj = 0;
31087 wxWindow *arg1 = (wxWindow *) 0 ;
31088 wxPoint result;
31089 void *argp1 = 0 ;
31090 int res1 = 0 ;
31091 PyObject *swig_obj[1] ;
31092
31093 if (!args) SWIG_fail;
31094 swig_obj[0] = args;
31095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31096 if (!SWIG_IsOK(res1)) {
31097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31098 }
31099 arg1 = reinterpret_cast< wxWindow * >(argp1);
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 result = ((wxWindow const *)arg1)->GetScreenPosition();
31103 wxPyEndAllowThreads(__tstate);
31104 if (PyErr_Occurred()) SWIG_fail;
31105 }
31106 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31114 PyObject *resultobj = 0;
31115 wxWindow *arg1 = (wxWindow *) 0 ;
31116 int *arg2 = (int *) 0 ;
31117 int *arg3 = (int *) 0 ;
31118 void *argp1 = 0 ;
31119 int res1 = 0 ;
31120 int temp2 ;
31121 int res2 = SWIG_TMPOBJ ;
31122 int temp3 ;
31123 int res3 = SWIG_TMPOBJ ;
31124 PyObject *swig_obj[1] ;
31125
31126 arg2 = &temp2;
31127 arg3 = &temp3;
31128 if (!args) SWIG_fail;
31129 swig_obj[0] = args;
31130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31133 }
31134 arg1 = reinterpret_cast< wxWindow * >(argp1);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_Py_Void();
31142 if (SWIG_IsTmpObj(res2)) {
31143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31144 } else {
31145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31147 }
31148 if (SWIG_IsTmpObj(res3)) {
31149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31150 } else {
31151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31153 }
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 PyObject *resultobj = 0;
31162 wxWindow *arg1 = (wxWindow *) 0 ;
31163 wxRect result;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 PyObject *swig_obj[1] ;
31167
31168 if (!args) SWIG_fail;
31169 swig_obj[0] = args;
31170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31171 if (!SWIG_IsOK(res1)) {
31172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31173 }
31174 arg1 = reinterpret_cast< wxWindow * >(argp1);
31175 {
31176 PyThreadState* __tstate = wxPyBeginAllowThreads();
31177 result = ((wxWindow const *)arg1)->GetScreenRect();
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31189 PyObject *resultobj = 0;
31190 wxWindow *arg1 = (wxWindow *) 0 ;
31191 wxSize result;
31192 void *argp1 = 0 ;
31193 int res1 = 0 ;
31194 PyObject *swig_obj[1] ;
31195
31196 if (!args) SWIG_fail;
31197 swig_obj[0] = args;
31198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31201 }
31202 arg1 = reinterpret_cast< wxWindow * >(argp1);
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = ((wxWindow const *)arg1)->GetSize();
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31217 PyObject *resultobj = 0;
31218 wxWindow *arg1 = (wxWindow *) 0 ;
31219 int *arg2 = (int *) 0 ;
31220 int *arg3 = (int *) 0 ;
31221 void *argp1 = 0 ;
31222 int res1 = 0 ;
31223 int temp2 ;
31224 int res2 = SWIG_TMPOBJ ;
31225 int temp3 ;
31226 int res3 = SWIG_TMPOBJ ;
31227 PyObject *swig_obj[1] ;
31228
31229 arg2 = &temp2;
31230 arg3 = &temp3;
31231 if (!args) SWIG_fail;
31232 swig_obj[0] = args;
31233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31234 if (!SWIG_IsOK(res1)) {
31235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31236 }
31237 arg1 = reinterpret_cast< wxWindow * >(argp1);
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 resultobj = SWIG_Py_Void();
31245 if (SWIG_IsTmpObj(res2)) {
31246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31247 } else {
31248 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31250 }
31251 if (SWIG_IsTmpObj(res3)) {
31252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31253 } else {
31254 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31256 }
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 wxWindow *arg1 = (wxWindow *) 0 ;
31266 wxRect result;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31276 }
31277 arg1 = reinterpret_cast< wxWindow * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = ((wxWindow const *)arg1)->GetRect();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31285 return resultobj;
31286 fail:
31287 return NULL;
31288 }
31289
31290
31291 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31292 PyObject *resultobj = 0;
31293 wxWindow *arg1 = (wxWindow *) 0 ;
31294 wxSize result;
31295 void *argp1 = 0 ;
31296 int res1 = 0 ;
31297 PyObject *swig_obj[1] ;
31298
31299 if (!args) SWIG_fail;
31300 swig_obj[0] = args;
31301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31302 if (!SWIG_IsOK(res1)) {
31303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31304 }
31305 arg1 = reinterpret_cast< wxWindow * >(argp1);
31306 {
31307 PyThreadState* __tstate = wxPyBeginAllowThreads();
31308 result = ((wxWindow const *)arg1)->GetClientSize();
31309 wxPyEndAllowThreads(__tstate);
31310 if (PyErr_Occurred()) SWIG_fail;
31311 }
31312 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31313 return resultobj;
31314 fail:
31315 return NULL;
31316 }
31317
31318
31319 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 PyObject *resultobj = 0;
31321 wxWindow *arg1 = (wxWindow *) 0 ;
31322 int *arg2 = (int *) 0 ;
31323 int *arg3 = (int *) 0 ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 int temp2 ;
31327 int res2 = SWIG_TMPOBJ ;
31328 int temp3 ;
31329 int res3 = SWIG_TMPOBJ ;
31330 PyObject *swig_obj[1] ;
31331
31332 arg2 = &temp2;
31333 arg3 = &temp3;
31334 if (!args) SWIG_fail;
31335 swig_obj[0] = args;
31336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31337 if (!SWIG_IsOK(res1)) {
31338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31339 }
31340 arg1 = reinterpret_cast< wxWindow * >(argp1);
31341 {
31342 PyThreadState* __tstate = wxPyBeginAllowThreads();
31343 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 resultobj = SWIG_Py_Void();
31348 if (SWIG_IsTmpObj(res2)) {
31349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31350 } else {
31351 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31353 }
31354 if (SWIG_IsTmpObj(res3)) {
31355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31356 } else {
31357 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31367 PyObject *resultobj = 0;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 wxPoint result;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 PyObject *swig_obj[1] ;
31373
31374 if (!args) SWIG_fail;
31375 swig_obj[0] = args;
31376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31379 }
31380 arg1 = reinterpret_cast< wxWindow * >(argp1);
31381 {
31382 PyThreadState* __tstate = wxPyBeginAllowThreads();
31383 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31395 PyObject *resultobj = 0;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 wxRect result;
31398 void *argp1 = 0 ;
31399 int res1 = 0 ;
31400 PyObject *swig_obj[1] ;
31401
31402 if (!args) SWIG_fail;
31403 swig_obj[0] = args;
31404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31405 if (!SWIG_IsOK(res1)) {
31406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31407 }
31408 arg1 = reinterpret_cast< wxWindow * >(argp1);
31409 {
31410 PyThreadState* __tstate = wxPyBeginAllowThreads();
31411 result = ((wxWindow const *)arg1)->GetClientRect();
31412 wxPyEndAllowThreads(__tstate);
31413 if (PyErr_Occurred()) SWIG_fail;
31414 }
31415 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31423 PyObject *resultobj = 0;
31424 wxWindow *arg1 = (wxWindow *) 0 ;
31425 wxSize result;
31426 void *argp1 = 0 ;
31427 int res1 = 0 ;
31428 PyObject *swig_obj[1] ;
31429
31430 if (!args) SWIG_fail;
31431 swig_obj[0] = args;
31432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31433 if (!SWIG_IsOK(res1)) {
31434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31435 }
31436 arg1 = reinterpret_cast< wxWindow * >(argp1);
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 result = ((wxWindow const *)arg1)->GetBestSize();
31440 wxPyEndAllowThreads(__tstate);
31441 if (PyErr_Occurred()) SWIG_fail;
31442 }
31443 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31451 PyObject *resultobj = 0;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 int *arg2 = (int *) 0 ;
31454 int *arg3 = (int *) 0 ;
31455 void *argp1 = 0 ;
31456 int res1 = 0 ;
31457 int temp2 ;
31458 int res2 = SWIG_TMPOBJ ;
31459 int temp3 ;
31460 int res3 = SWIG_TMPOBJ ;
31461 PyObject *swig_obj[1] ;
31462
31463 arg2 = &temp2;
31464 arg3 = &temp3;
31465 if (!args) SWIG_fail;
31466 swig_obj[0] = args;
31467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31468 if (!SWIG_IsOK(res1)) {
31469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31470 }
31471 arg1 = reinterpret_cast< wxWindow * >(argp1);
31472 {
31473 PyThreadState* __tstate = wxPyBeginAllowThreads();
31474 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31475 wxPyEndAllowThreads(__tstate);
31476 if (PyErr_Occurred()) SWIG_fail;
31477 }
31478 resultobj = SWIG_Py_Void();
31479 if (SWIG_IsTmpObj(res2)) {
31480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31481 } else {
31482 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31484 }
31485 if (SWIG_IsTmpObj(res3)) {
31486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31487 } else {
31488 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31490 }
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31498 PyObject *resultobj = 0;
31499 wxWindow *arg1 = (wxWindow *) 0 ;
31500 void *argp1 = 0 ;
31501 int res1 = 0 ;
31502 PyObject *swig_obj[1] ;
31503
31504 if (!args) SWIG_fail;
31505 swig_obj[0] = args;
31506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31507 if (!SWIG_IsOK(res1)) {
31508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31509 }
31510 arg1 = reinterpret_cast< wxWindow * >(argp1);
31511 {
31512 PyThreadState* __tstate = wxPyBeginAllowThreads();
31513 (arg1)->InvalidateBestSize();
31514 wxPyEndAllowThreads(__tstate);
31515 if (PyErr_Occurred()) SWIG_fail;
31516 }
31517 resultobj = SWIG_Py_Void();
31518 return resultobj;
31519 fail:
31520 return NULL;
31521 }
31522
31523
31524 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31525 PyObject *resultobj = 0;
31526 wxWindow *arg1 = (wxWindow *) 0 ;
31527 wxSize *arg2 = 0 ;
31528 void *argp1 = 0 ;
31529 int res1 = 0 ;
31530 wxSize temp2 ;
31531 PyObject * obj0 = 0 ;
31532 PyObject * obj1 = 0 ;
31533 char * kwnames[] = {
31534 (char *) "self",(char *) "size", NULL
31535 };
31536
31537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31539 if (!SWIG_IsOK(res1)) {
31540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31541 }
31542 arg1 = reinterpret_cast< wxWindow * >(argp1);
31543 {
31544 arg2 = &temp2;
31545 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31546 }
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 resultobj = SWIG_Py_Void();
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31561 PyObject *resultobj = 0;
31562 wxWindow *arg1 = (wxWindow *) 0 ;
31563 wxSize result;
31564 void *argp1 = 0 ;
31565 int res1 = 0 ;
31566 PyObject *swig_obj[1] ;
31567
31568 if (!args) SWIG_fail;
31569 swig_obj[0] = args;
31570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31571 if (!SWIG_IsOK(res1)) {
31572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31573 }
31574 arg1 = reinterpret_cast< wxWindow * >(argp1);
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *resultobj = 0;
31590 wxWindow *arg1 = (wxWindow *) 0 ;
31591 wxSize result;
31592 void *argp1 = 0 ;
31593 int res1 = 0 ;
31594 PyObject *swig_obj[1] ;
31595
31596 if (!args) SWIG_fail;
31597 swig_obj[0] = args;
31598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31599 if (!SWIG_IsOK(res1)) {
31600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31601 }
31602 arg1 = reinterpret_cast< wxWindow * >(argp1);
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31610 return resultobj;
31611 fail:
31612 return NULL;
31613 }
31614
31615
31616 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31617 PyObject *resultobj = 0;
31618 wxWindow *arg1 = (wxWindow *) 0 ;
31619 int arg2 = (int) wxBOTH ;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 int val2 ;
31623 int ecode2 = 0 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "self",(char *) "direction", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31634 }
31635 arg1 = reinterpret_cast< wxWindow * >(argp1);
31636 if (obj1) {
31637 ecode2 = SWIG_AsVal_int(obj1, &val2);
31638 if (!SWIG_IsOK(ecode2)) {
31639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31640 }
31641 arg2 = static_cast< int >(val2);
31642 }
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->Center(arg2);
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_Py_Void();
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31657 PyObject *resultobj = 0;
31658 wxWindow *arg1 = (wxWindow *) 0 ;
31659 int arg2 = (int) wxBOTH ;
31660 void *argp1 = 0 ;
31661 int res1 = 0 ;
31662 int val2 ;
31663 int ecode2 = 0 ;
31664 PyObject * obj0 = 0 ;
31665 PyObject * obj1 = 0 ;
31666 char * kwnames[] = {
31667 (char *) "self",(char *) "dir", NULL
31668 };
31669
31670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31672 if (!SWIG_IsOK(res1)) {
31673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31674 }
31675 arg1 = reinterpret_cast< wxWindow * >(argp1);
31676 if (obj1) {
31677 ecode2 = SWIG_AsVal_int(obj1, &val2);
31678 if (!SWIG_IsOK(ecode2)) {
31679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31680 }
31681 arg2 = static_cast< int >(val2);
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 (arg1)->CenterOnParent(arg2);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31697 PyObject *resultobj = 0;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 void *argp1 = 0 ;
31700 int res1 = 0 ;
31701 PyObject *swig_obj[1] ;
31702
31703 if (!args) SWIG_fail;
31704 swig_obj[0] = args;
31705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31706 if (!SWIG_IsOK(res1)) {
31707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31708 }
31709 arg1 = reinterpret_cast< wxWindow * >(argp1);
31710 {
31711 PyThreadState* __tstate = wxPyBeginAllowThreads();
31712 (arg1)->Fit();
31713 wxPyEndAllowThreads(__tstate);
31714 if (PyErr_Occurred()) SWIG_fail;
31715 }
31716 resultobj = SWIG_Py_Void();
31717 return resultobj;
31718 fail:
31719 return NULL;
31720 }
31721
31722
31723 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31724 PyObject *resultobj = 0;
31725 wxWindow *arg1 = (wxWindow *) 0 ;
31726 void *argp1 = 0 ;
31727 int res1 = 0 ;
31728 PyObject *swig_obj[1] ;
31729
31730 if (!args) SWIG_fail;
31731 swig_obj[0] = args;
31732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31735 }
31736 arg1 = reinterpret_cast< wxWindow * >(argp1);
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 (arg1)->FitInside();
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_Py_Void();
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31751 PyObject *resultobj = 0;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 int arg2 ;
31754 int arg3 ;
31755 int arg4 = (int) -1 ;
31756 int arg5 = (int) -1 ;
31757 int arg6 = (int) -1 ;
31758 int arg7 = (int) -1 ;
31759 void *argp1 = 0 ;
31760 int res1 = 0 ;
31761 int val2 ;
31762 int ecode2 = 0 ;
31763 int val3 ;
31764 int ecode3 = 0 ;
31765 int val4 ;
31766 int ecode4 = 0 ;
31767 int val5 ;
31768 int ecode5 = 0 ;
31769 int val6 ;
31770 int ecode6 = 0 ;
31771 int val7 ;
31772 int ecode7 = 0 ;
31773 PyObject * obj0 = 0 ;
31774 PyObject * obj1 = 0 ;
31775 PyObject * obj2 = 0 ;
31776 PyObject * obj3 = 0 ;
31777 PyObject * obj4 = 0 ;
31778 PyObject * obj5 = 0 ;
31779 PyObject * obj6 = 0 ;
31780 char * kwnames[] = {
31781 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31782 };
31783
31784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31786 if (!SWIG_IsOK(res1)) {
31787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31788 }
31789 arg1 = reinterpret_cast< wxWindow * >(argp1);
31790 ecode2 = SWIG_AsVal_int(obj1, &val2);
31791 if (!SWIG_IsOK(ecode2)) {
31792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31793 }
31794 arg2 = static_cast< int >(val2);
31795 ecode3 = SWIG_AsVal_int(obj2, &val3);
31796 if (!SWIG_IsOK(ecode3)) {
31797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31798 }
31799 arg3 = static_cast< int >(val3);
31800 if (obj3) {
31801 ecode4 = SWIG_AsVal_int(obj3, &val4);
31802 if (!SWIG_IsOK(ecode4)) {
31803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31804 }
31805 arg4 = static_cast< int >(val4);
31806 }
31807 if (obj4) {
31808 ecode5 = SWIG_AsVal_int(obj4, &val5);
31809 if (!SWIG_IsOK(ecode5)) {
31810 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31811 }
31812 arg5 = static_cast< int >(val5);
31813 }
31814 if (obj5) {
31815 ecode6 = SWIG_AsVal_int(obj5, &val6);
31816 if (!SWIG_IsOK(ecode6)) {
31817 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31818 }
31819 arg6 = static_cast< int >(val6);
31820 }
31821 if (obj6) {
31822 ecode7 = SWIG_AsVal_int(obj6, &val7);
31823 if (!SWIG_IsOK(ecode7)) {
31824 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31825 }
31826 arg7 = static_cast< int >(val7);
31827 }
31828 {
31829 PyThreadState* __tstate = wxPyBeginAllowThreads();
31830 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31831 wxPyEndAllowThreads(__tstate);
31832 if (PyErr_Occurred()) SWIG_fail;
31833 }
31834 resultobj = SWIG_Py_Void();
31835 return resultobj;
31836 fail:
31837 return NULL;
31838 }
31839
31840
31841 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31842 PyObject *resultobj = 0;
31843 wxWindow *arg1 = (wxWindow *) 0 ;
31844 wxSize *arg2 = 0 ;
31845 wxSize const &arg3_defvalue = wxDefaultSize ;
31846 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31847 wxSize const &arg4_defvalue = wxDefaultSize ;
31848 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31849 void *argp1 = 0 ;
31850 int res1 = 0 ;
31851 wxSize temp2 ;
31852 wxSize temp3 ;
31853 wxSize temp4 ;
31854 PyObject * obj0 = 0 ;
31855 PyObject * obj1 = 0 ;
31856 PyObject * obj2 = 0 ;
31857 PyObject * obj3 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 arg2 = &temp2;
31870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31871 }
31872 if (obj2) {
31873 {
31874 arg3 = &temp3;
31875 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31876 }
31877 }
31878 if (obj3) {
31879 {
31880 arg4 = &temp4;
31881 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31882 }
31883 }
31884 {
31885 PyThreadState* __tstate = wxPyBeginAllowThreads();
31886 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31887 wxPyEndAllowThreads(__tstate);
31888 if (PyErr_Occurred()) SWIG_fail;
31889 }
31890 resultobj = SWIG_Py_Void();
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj = 0;
31899 wxWindow *arg1 = (wxWindow *) 0 ;
31900 int arg2 ;
31901 int arg3 ;
31902 int arg4 = (int) -1 ;
31903 int arg5 = (int) -1 ;
31904 void *argp1 = 0 ;
31905 int res1 = 0 ;
31906 int val2 ;
31907 int ecode2 = 0 ;
31908 int val3 ;
31909 int ecode3 = 0 ;
31910 int val4 ;
31911 int ecode4 = 0 ;
31912 int val5 ;
31913 int ecode5 = 0 ;
31914 PyObject * obj0 = 0 ;
31915 PyObject * obj1 = 0 ;
31916 PyObject * obj2 = 0 ;
31917 PyObject * obj3 = 0 ;
31918 PyObject * obj4 = 0 ;
31919 char * kwnames[] = {
31920 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31921 };
31922
31923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31927 }
31928 arg1 = reinterpret_cast< wxWindow * >(argp1);
31929 ecode2 = SWIG_AsVal_int(obj1, &val2);
31930 if (!SWIG_IsOK(ecode2)) {
31931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31932 }
31933 arg2 = static_cast< int >(val2);
31934 ecode3 = SWIG_AsVal_int(obj2, &val3);
31935 if (!SWIG_IsOK(ecode3)) {
31936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31937 }
31938 arg3 = static_cast< int >(val3);
31939 if (obj3) {
31940 ecode4 = SWIG_AsVal_int(obj3, &val4);
31941 if (!SWIG_IsOK(ecode4)) {
31942 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31943 }
31944 arg4 = static_cast< int >(val4);
31945 }
31946 if (obj4) {
31947 ecode5 = SWIG_AsVal_int(obj4, &val5);
31948 if (!SWIG_IsOK(ecode5)) {
31949 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31950 }
31951 arg5 = static_cast< int >(val5);
31952 }
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_Py_Void();
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 wxSize *arg2 = 0 ;
31970 wxSize const &arg3_defvalue = wxDefaultSize ;
31971 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31972 void *argp1 = 0 ;
31973 int res1 = 0 ;
31974 wxSize temp2 ;
31975 wxSize temp3 ;
31976 PyObject * obj0 = 0 ;
31977 PyObject * obj1 = 0 ;
31978 PyObject * obj2 = 0 ;
31979 char * kwnames[] = {
31980 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31981 };
31982
31983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31985 if (!SWIG_IsOK(res1)) {
31986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31987 }
31988 arg1 = reinterpret_cast< wxWindow * >(argp1);
31989 {
31990 arg2 = &temp2;
31991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31992 }
31993 if (obj2) {
31994 {
31995 arg3 = &temp3;
31996 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31997 }
31998 }
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32002 wxPyEndAllowThreads(__tstate);
32003 if (PyErr_Occurred()) SWIG_fail;
32004 }
32005 resultobj = SWIG_Py_Void();
32006 return resultobj;
32007 fail:
32008 return NULL;
32009 }
32010
32011
32012 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32013 PyObject *resultobj = 0;
32014 wxWindow *arg1 = (wxWindow *) 0 ;
32015 wxSize result;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 PyObject *swig_obj[1] ;
32019
32020 if (!args) SWIG_fail;
32021 swig_obj[0] = args;
32022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32023 if (!SWIG_IsOK(res1)) {
32024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32025 }
32026 arg1 = reinterpret_cast< wxWindow * >(argp1);
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 result = ((wxWindow const *)arg1)->GetMaxSize();
32030 wxPyEndAllowThreads(__tstate);
32031 if (PyErr_Occurred()) SWIG_fail;
32032 }
32033 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32034 return resultobj;
32035 fail:
32036 return NULL;
32037 }
32038
32039
32040 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32041 PyObject *resultobj = 0;
32042 wxWindow *arg1 = (wxWindow *) 0 ;
32043 wxSize result;
32044 void *argp1 = 0 ;
32045 int res1 = 0 ;
32046 PyObject *swig_obj[1] ;
32047
32048 if (!args) SWIG_fail;
32049 swig_obj[0] = args;
32050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32051 if (!SWIG_IsOK(res1)) {
32052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32053 }
32054 arg1 = reinterpret_cast< wxWindow * >(argp1);
32055 {
32056 PyThreadState* __tstate = wxPyBeginAllowThreads();
32057 result = ((wxWindow const *)arg1)->GetMinSize();
32058 wxPyEndAllowThreads(__tstate);
32059 if (PyErr_Occurred()) SWIG_fail;
32060 }
32061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32062 return resultobj;
32063 fail:
32064 return NULL;
32065 }
32066
32067
32068 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32069 PyObject *resultobj = 0;
32070 wxWindow *arg1 = (wxWindow *) 0 ;
32071 wxSize *arg2 = 0 ;
32072 void *argp1 = 0 ;
32073 int res1 = 0 ;
32074 wxSize temp2 ;
32075 PyObject * obj0 = 0 ;
32076 PyObject * obj1 = 0 ;
32077 char * kwnames[] = {
32078 (char *) "self",(char *) "minSize", NULL
32079 };
32080
32081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32083 if (!SWIG_IsOK(res1)) {
32084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32085 }
32086 arg1 = reinterpret_cast< wxWindow * >(argp1);
32087 {
32088 arg2 = &temp2;
32089 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32090 }
32091 {
32092 PyThreadState* __tstate = wxPyBeginAllowThreads();
32093 (arg1)->SetMinSize((wxSize const &)*arg2);
32094 wxPyEndAllowThreads(__tstate);
32095 if (PyErr_Occurred()) SWIG_fail;
32096 }
32097 resultobj = SWIG_Py_Void();
32098 return resultobj;
32099 fail:
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32105 PyObject *resultobj = 0;
32106 wxWindow *arg1 = (wxWindow *) 0 ;
32107 wxSize *arg2 = 0 ;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 wxSize temp2 ;
32111 PyObject * obj0 = 0 ;
32112 PyObject * obj1 = 0 ;
32113 char * kwnames[] = {
32114 (char *) "self",(char *) "maxSize", NULL
32115 };
32116
32117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32119 if (!SWIG_IsOK(res1)) {
32120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32121 }
32122 arg1 = reinterpret_cast< wxWindow * >(argp1);
32123 {
32124 arg2 = &temp2;
32125 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 (arg1)->SetMaxSize((wxSize const &)*arg2);
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_Py_Void();
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32141 PyObject *resultobj = 0;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 int result;
32144 void *argp1 = 0 ;
32145 int res1 = 0 ;
32146 PyObject *swig_obj[1] ;
32147
32148 if (!args) SWIG_fail;
32149 swig_obj[0] = args;
32150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 resultobj = SWIG_From_int(static_cast< int >(result));
32162 return resultobj;
32163 fail:
32164 return NULL;
32165 }
32166
32167
32168 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32169 PyObject *resultobj = 0;
32170 wxWindow *arg1 = (wxWindow *) 0 ;
32171 int result;
32172 void *argp1 = 0 ;
32173 int res1 = 0 ;
32174 PyObject *swig_obj[1] ;
32175
32176 if (!args) SWIG_fail;
32177 swig_obj[0] = args;
32178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32179 if (!SWIG_IsOK(res1)) {
32180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32181 }
32182 arg1 = reinterpret_cast< wxWindow * >(argp1);
32183 {
32184 PyThreadState* __tstate = wxPyBeginAllowThreads();
32185 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32186 wxPyEndAllowThreads(__tstate);
32187 if (PyErr_Occurred()) SWIG_fail;
32188 }
32189 resultobj = SWIG_From_int(static_cast< int >(result));
32190 return resultobj;
32191 fail:
32192 return NULL;
32193 }
32194
32195
32196 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32197 PyObject *resultobj = 0;
32198 wxWindow *arg1 = (wxWindow *) 0 ;
32199 int result;
32200 void *argp1 = 0 ;
32201 int res1 = 0 ;
32202 PyObject *swig_obj[1] ;
32203
32204 if (!args) SWIG_fail;
32205 swig_obj[0] = args;
32206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32207 if (!SWIG_IsOK(res1)) {
32208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32209 }
32210 arg1 = reinterpret_cast< wxWindow * >(argp1);
32211 {
32212 PyThreadState* __tstate = wxPyBeginAllowThreads();
32213 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32214 wxPyEndAllowThreads(__tstate);
32215 if (PyErr_Occurred()) SWIG_fail;
32216 }
32217 resultobj = SWIG_From_int(static_cast< int >(result));
32218 return resultobj;
32219 fail:
32220 return NULL;
32221 }
32222
32223
32224 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32225 PyObject *resultobj = 0;
32226 wxWindow *arg1 = (wxWindow *) 0 ;
32227 int result;
32228 void *argp1 = 0 ;
32229 int res1 = 0 ;
32230 PyObject *swig_obj[1] ;
32231
32232 if (!args) SWIG_fail;
32233 swig_obj[0] = args;
32234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32235 if (!SWIG_IsOK(res1)) {
32236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32237 }
32238 arg1 = reinterpret_cast< wxWindow * >(argp1);
32239 {
32240 PyThreadState* __tstate = wxPyBeginAllowThreads();
32241 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32242 wxPyEndAllowThreads(__tstate);
32243 if (PyErr_Occurred()) SWIG_fail;
32244 }
32245 resultobj = SWIG_From_int(static_cast< int >(result));
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32253 PyObject *resultobj = 0;
32254 wxWindow *arg1 = (wxWindow *) 0 ;
32255 wxSize *arg2 = 0 ;
32256 void *argp1 = 0 ;
32257 int res1 = 0 ;
32258 wxSize temp2 ;
32259 PyObject * obj0 = 0 ;
32260 PyObject * obj1 = 0 ;
32261 char * kwnames[] = {
32262 (char *) "self",(char *) "size", NULL
32263 };
32264
32265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32267 if (!SWIG_IsOK(res1)) {
32268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32269 }
32270 arg1 = reinterpret_cast< wxWindow * >(argp1);
32271 {
32272 arg2 = &temp2;
32273 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32274 }
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32278 wxPyEndAllowThreads(__tstate);
32279 if (PyErr_Occurred()) SWIG_fail;
32280 }
32281 resultobj = SWIG_Py_Void();
32282 return resultobj;
32283 fail:
32284 return NULL;
32285 }
32286
32287
32288 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32289 PyObject *resultobj = 0;
32290 wxWindow *arg1 = (wxWindow *) 0 ;
32291 int arg2 ;
32292 int arg3 ;
32293 void *argp1 = 0 ;
32294 int res1 = 0 ;
32295 int val2 ;
32296 int ecode2 = 0 ;
32297 int val3 ;
32298 int ecode3 = 0 ;
32299 PyObject * obj0 = 0 ;
32300 PyObject * obj1 = 0 ;
32301 PyObject * obj2 = 0 ;
32302 char * kwnames[] = {
32303 (char *) "self",(char *) "w",(char *) "h", NULL
32304 };
32305
32306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32308 if (!SWIG_IsOK(res1)) {
32309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32310 }
32311 arg1 = reinterpret_cast< wxWindow * >(argp1);
32312 ecode2 = SWIG_AsVal_int(obj1, &val2);
32313 if (!SWIG_IsOK(ecode2)) {
32314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32315 }
32316 arg2 = static_cast< int >(val2);
32317 ecode3 = SWIG_AsVal_int(obj2, &val3);
32318 if (!SWIG_IsOK(ecode3)) {
32319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32320 }
32321 arg3 = static_cast< int >(val3);
32322 {
32323 PyThreadState* __tstate = wxPyBeginAllowThreads();
32324 (arg1)->SetVirtualSize(arg2,arg3);
32325 wxPyEndAllowThreads(__tstate);
32326 if (PyErr_Occurred()) SWIG_fail;
32327 }
32328 resultobj = SWIG_Py_Void();
32329 return resultobj;
32330 fail:
32331 return NULL;
32332 }
32333
32334
32335 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32336 PyObject *resultobj = 0;
32337 wxWindow *arg1 = (wxWindow *) 0 ;
32338 wxSize result;
32339 void *argp1 = 0 ;
32340 int res1 = 0 ;
32341 PyObject *swig_obj[1] ;
32342
32343 if (!args) SWIG_fail;
32344 swig_obj[0] = args;
32345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32348 }
32349 arg1 = reinterpret_cast< wxWindow * >(argp1);
32350 {
32351 PyThreadState* __tstate = wxPyBeginAllowThreads();
32352 result = ((wxWindow const *)arg1)->GetVirtualSize();
32353 wxPyEndAllowThreads(__tstate);
32354 if (PyErr_Occurred()) SWIG_fail;
32355 }
32356 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32357 return resultobj;
32358 fail:
32359 return NULL;
32360 }
32361
32362
32363 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32364 PyObject *resultobj = 0;
32365 wxWindow *arg1 = (wxWindow *) 0 ;
32366 int *arg2 = (int *) 0 ;
32367 int *arg3 = (int *) 0 ;
32368 void *argp1 = 0 ;
32369 int res1 = 0 ;
32370 int temp2 ;
32371 int res2 = SWIG_TMPOBJ ;
32372 int temp3 ;
32373 int res3 = SWIG_TMPOBJ ;
32374 PyObject *swig_obj[1] ;
32375
32376 arg2 = &temp2;
32377 arg3 = &temp3;
32378 if (!args) SWIG_fail;
32379 swig_obj[0] = args;
32380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32381 if (!SWIG_IsOK(res1)) {
32382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32383 }
32384 arg1 = reinterpret_cast< wxWindow * >(argp1);
32385 {
32386 PyThreadState* __tstate = wxPyBeginAllowThreads();
32387 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32388 wxPyEndAllowThreads(__tstate);
32389 if (PyErr_Occurred()) SWIG_fail;
32390 }
32391 resultobj = SWIG_Py_Void();
32392 if (SWIG_IsTmpObj(res2)) {
32393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32394 } else {
32395 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32397 }
32398 if (SWIG_IsTmpObj(res3)) {
32399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32400 } else {
32401 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32403 }
32404 return resultobj;
32405 fail:
32406 return NULL;
32407 }
32408
32409
32410 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 PyObject *resultobj = 0;
32412 wxWindow *arg1 = (wxWindow *) 0 ;
32413 wxSize 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_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32423 }
32424 arg1 = reinterpret_cast< wxWindow * >(argp1);
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32439 PyObject *resultobj = 0;
32440 wxWindow *arg1 = (wxWindow *) 0 ;
32441 bool arg2 = (bool) true ;
32442 bool result;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 bool val2 ;
32446 int ecode2 = 0 ;
32447 PyObject * obj0 = 0 ;
32448 PyObject * obj1 = 0 ;
32449 char * kwnames[] = {
32450 (char *) "self",(char *) "show", NULL
32451 };
32452
32453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32455 if (!SWIG_IsOK(res1)) {
32456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32457 }
32458 arg1 = reinterpret_cast< wxWindow * >(argp1);
32459 if (obj1) {
32460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32461 if (!SWIG_IsOK(ecode2)) {
32462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32463 }
32464 arg2 = static_cast< bool >(val2);
32465 }
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 result = (bool)(arg1)->Show(arg2);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 {
32473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32474 }
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 bool result;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32494 }
32495 arg1 = reinterpret_cast< wxWindow * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (bool)(arg1)->Hide();
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 {
32503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32504 }
32505 return resultobj;
32506 fail:
32507 return NULL;
32508 }
32509
32510
32511 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32512 PyObject *resultobj = 0;
32513 wxWindow *arg1 = (wxWindow *) 0 ;
32514 bool arg2 = (bool) true ;
32515 bool result;
32516 void *argp1 = 0 ;
32517 int res1 = 0 ;
32518 bool val2 ;
32519 int ecode2 = 0 ;
32520 PyObject * obj0 = 0 ;
32521 PyObject * obj1 = 0 ;
32522 char * kwnames[] = {
32523 (char *) "self",(char *) "enable", NULL
32524 };
32525
32526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32530 }
32531 arg1 = reinterpret_cast< wxWindow * >(argp1);
32532 if (obj1) {
32533 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32534 if (!SWIG_IsOK(ecode2)) {
32535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32536 }
32537 arg2 = static_cast< bool >(val2);
32538 }
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (bool)(arg1)->Enable(arg2);
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 {
32546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32547 }
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *resultobj = 0;
32556 wxWindow *arg1 = (wxWindow *) 0 ;
32557 bool result;
32558 void *argp1 = 0 ;
32559 int res1 = 0 ;
32560 PyObject *swig_obj[1] ;
32561
32562 if (!args) SWIG_fail;
32563 swig_obj[0] = args;
32564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32567 }
32568 arg1 = reinterpret_cast< wxWindow * >(argp1);
32569 {
32570 PyThreadState* __tstate = wxPyBeginAllowThreads();
32571 result = (bool)(arg1)->Disable();
32572 wxPyEndAllowThreads(__tstate);
32573 if (PyErr_Occurred()) SWIG_fail;
32574 }
32575 {
32576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32577 }
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxWindow *arg1 = (wxWindow *) 0 ;
32587 bool result;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 PyObject *swig_obj[1] ;
32591
32592 if (!args) SWIG_fail;
32593 swig_obj[0] = args;
32594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32595 if (!SWIG_IsOK(res1)) {
32596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32597 }
32598 arg1 = reinterpret_cast< wxWindow * >(argp1);
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 result = (bool)((wxWindow const *)arg1)->IsShown();
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 {
32606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32607 }
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *resultobj = 0;
32616 wxWindow *arg1 = (wxWindow *) 0 ;
32617 bool result;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 PyObject *swig_obj[1] ;
32621
32622 if (!args) SWIG_fail;
32623 swig_obj[0] = args;
32624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32625 if (!SWIG_IsOK(res1)) {
32626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32627 }
32628 arg1 = reinterpret_cast< wxWindow * >(argp1);
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32632 wxPyEndAllowThreads(__tstate);
32633 if (PyErr_Occurred()) SWIG_fail;
32634 }
32635 {
32636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32637 }
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 long arg2 ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 long val2 ;
32651 int ecode2 = 0 ;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 char * kwnames[] = {
32655 (char *) "self",(char *) "style", NULL
32656 };
32657
32658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32660 if (!SWIG_IsOK(res1)) {
32661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32662 }
32663 arg1 = reinterpret_cast< wxWindow * >(argp1);
32664 ecode2 = SWIG_AsVal_long(obj1, &val2);
32665 if (!SWIG_IsOK(ecode2)) {
32666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32667 }
32668 arg2 = static_cast< long >(val2);
32669 {
32670 PyThreadState* __tstate = wxPyBeginAllowThreads();
32671 (arg1)->SetWindowStyleFlag(arg2);
32672 wxPyEndAllowThreads(__tstate);
32673 if (PyErr_Occurred()) SWIG_fail;
32674 }
32675 resultobj = SWIG_Py_Void();
32676 return resultobj;
32677 fail:
32678 return NULL;
32679 }
32680
32681
32682 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 PyObject *resultobj = 0;
32684 wxWindow *arg1 = (wxWindow *) 0 ;
32685 long result;
32686 void *argp1 = 0 ;
32687 int res1 = 0 ;
32688 PyObject *swig_obj[1] ;
32689
32690 if (!args) SWIG_fail;
32691 swig_obj[0] = args;
32692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32695 }
32696 arg1 = reinterpret_cast< wxWindow * >(argp1);
32697 {
32698 PyThreadState* __tstate = wxPyBeginAllowThreads();
32699 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32700 wxPyEndAllowThreads(__tstate);
32701 if (PyErr_Occurred()) SWIG_fail;
32702 }
32703 resultobj = SWIG_From_long(static_cast< long >(result));
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32711 PyObject *resultobj = 0;
32712 wxWindow *arg1 = (wxWindow *) 0 ;
32713 int arg2 ;
32714 bool result;
32715 void *argp1 = 0 ;
32716 int res1 = 0 ;
32717 int val2 ;
32718 int ecode2 = 0 ;
32719 PyObject * obj0 = 0 ;
32720 PyObject * obj1 = 0 ;
32721 char * kwnames[] = {
32722 (char *) "self",(char *) "flag", NULL
32723 };
32724
32725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32727 if (!SWIG_IsOK(res1)) {
32728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32729 }
32730 arg1 = reinterpret_cast< wxWindow * >(argp1);
32731 ecode2 = SWIG_AsVal_int(obj1, &val2);
32732 if (!SWIG_IsOK(ecode2)) {
32733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32734 }
32735 arg2 = static_cast< int >(val2);
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 bool result;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 PyObject *swig_obj[1] ;
32758
32759 if (!args) SWIG_fail;
32760 swig_obj[0] = args;
32761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32762 if (!SWIG_IsOK(res1)) {
32763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32764 }
32765 arg1 = reinterpret_cast< wxWindow * >(argp1);
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 result = (bool)((wxWindow const *)arg1)->IsRetained();
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 {
32773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32774 }
32775 return resultobj;
32776 fail:
32777 return NULL;
32778 }
32779
32780
32781 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj = 0;
32783 wxWindow *arg1 = (wxWindow *) 0 ;
32784 long arg2 ;
32785 void *argp1 = 0 ;
32786 int res1 = 0 ;
32787 long val2 ;
32788 int ecode2 = 0 ;
32789 PyObject * obj0 = 0 ;
32790 PyObject * obj1 = 0 ;
32791 char * kwnames[] = {
32792 (char *) "self",(char *) "exStyle", NULL
32793 };
32794
32795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32797 if (!SWIG_IsOK(res1)) {
32798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32799 }
32800 arg1 = reinterpret_cast< wxWindow * >(argp1);
32801 ecode2 = SWIG_AsVal_long(obj1, &val2);
32802 if (!SWIG_IsOK(ecode2)) {
32803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32804 }
32805 arg2 = static_cast< long >(val2);
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 (arg1)->SetExtraStyle(arg2);
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 resultobj = SWIG_Py_Void();
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32820 PyObject *resultobj = 0;
32821 wxWindow *arg1 = (wxWindow *) 0 ;
32822 long result;
32823 void *argp1 = 0 ;
32824 int res1 = 0 ;
32825 PyObject *swig_obj[1] ;
32826
32827 if (!args) SWIG_fail;
32828 swig_obj[0] = args;
32829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32832 }
32833 arg1 = reinterpret_cast< wxWindow * >(argp1);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 resultobj = SWIG_From_long(static_cast< long >(result));
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32848 PyObject *resultobj = 0;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 bool arg2 = (bool) true ;
32851 void *argp1 = 0 ;
32852 int res1 = 0 ;
32853 bool val2 ;
32854 int ecode2 = 0 ;
32855 PyObject * obj0 = 0 ;
32856 PyObject * obj1 = 0 ;
32857 char * kwnames[] = {
32858 (char *) "self",(char *) "modal", NULL
32859 };
32860
32861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32863 if (!SWIG_IsOK(res1)) {
32864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32865 }
32866 arg1 = reinterpret_cast< wxWindow * >(argp1);
32867 if (obj1) {
32868 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32869 if (!SWIG_IsOK(ecode2)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32871 }
32872 arg2 = static_cast< bool >(val2);
32873 }
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 (arg1)->MakeModal(arg2);
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 resultobj = SWIG_Py_Void();
32881 return resultobj;
32882 fail:
32883 return NULL;
32884 }
32885
32886
32887 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32888 PyObject *resultobj = 0;
32889 wxWindow *arg1 = (wxWindow *) 0 ;
32890 bool arg2 ;
32891 void *argp1 = 0 ;
32892 int res1 = 0 ;
32893 bool val2 ;
32894 int ecode2 = 0 ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 char * kwnames[] = {
32898 (char *) "self",(char *) "enableTheme", NULL
32899 };
32900
32901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32903 if (!SWIG_IsOK(res1)) {
32904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32905 }
32906 arg1 = reinterpret_cast< wxWindow * >(argp1);
32907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32908 if (!SWIG_IsOK(ecode2)) {
32909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32910 }
32911 arg2 = static_cast< bool >(val2);
32912 {
32913 PyThreadState* __tstate = wxPyBeginAllowThreads();
32914 (arg1)->SetThemeEnabled(arg2);
32915 wxPyEndAllowThreads(__tstate);
32916 if (PyErr_Occurred()) SWIG_fail;
32917 }
32918 resultobj = SWIG_Py_Void();
32919 return resultobj;
32920 fail:
32921 return NULL;
32922 }
32923
32924
32925 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32926 PyObject *resultobj = 0;
32927 wxWindow *arg1 = (wxWindow *) 0 ;
32928 bool result;
32929 void *argp1 = 0 ;
32930 int res1 = 0 ;
32931 PyObject *swig_obj[1] ;
32932
32933 if (!args) SWIG_fail;
32934 swig_obj[0] = args;
32935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32936 if (!SWIG_IsOK(res1)) {
32937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32938 }
32939 arg1 = reinterpret_cast< wxWindow * >(argp1);
32940 {
32941 PyThreadState* __tstate = wxPyBeginAllowThreads();
32942 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32943 wxPyEndAllowThreads(__tstate);
32944 if (PyErr_Occurred()) SWIG_fail;
32945 }
32946 {
32947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32948 }
32949 return resultobj;
32950 fail:
32951 return NULL;
32952 }
32953
32954
32955 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32956 PyObject *resultobj = 0;
32957 wxWindow *arg1 = (wxWindow *) 0 ;
32958 void *argp1 = 0 ;
32959 int res1 = 0 ;
32960 PyObject *swig_obj[1] ;
32961
32962 if (!args) SWIG_fail;
32963 swig_obj[0] = args;
32964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32965 if (!SWIG_IsOK(res1)) {
32966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32967 }
32968 arg1 = reinterpret_cast< wxWindow * >(argp1);
32969 {
32970 PyThreadState* __tstate = wxPyBeginAllowThreads();
32971 (arg1)->SetFocus();
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 resultobj = SWIG_Py_Void();
32976 return resultobj;
32977 fail:
32978 return NULL;
32979 }
32980
32981
32982 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32983 PyObject *resultobj = 0;
32984 wxWindow *arg1 = (wxWindow *) 0 ;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 PyObject *swig_obj[1] ;
32988
32989 if (!args) SWIG_fail;
32990 swig_obj[0] = args;
32991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32992 if (!SWIG_IsOK(res1)) {
32993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32994 }
32995 arg1 = reinterpret_cast< wxWindow * >(argp1);
32996 {
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 (arg1)->SetFocusFromKbd();
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 resultobj = SWIG_Py_Void();
33003 return resultobj;
33004 fail:
33005 return NULL;
33006 }
33007
33008
33009 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33010 PyObject *resultobj = 0;
33011 wxWindow *result = 0 ;
33012
33013 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33014 {
33015 if (!wxPyCheckForApp()) SWIG_fail;
33016 PyThreadState* __tstate = wxPyBeginAllowThreads();
33017 result = (wxWindow *)wxWindow::FindFocus();
33018 wxPyEndAllowThreads(__tstate);
33019 if (PyErr_Occurred()) SWIG_fail;
33020 }
33021 {
33022 resultobj = wxPyMake_wxObject(result, 0);
33023 }
33024 return resultobj;
33025 fail:
33026 return NULL;
33027 }
33028
33029
33030 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33031 PyObject *resultobj = 0;
33032 wxWindow *arg1 = (wxWindow *) 0 ;
33033 bool result;
33034 void *argp1 = 0 ;
33035 int res1 = 0 ;
33036 PyObject *swig_obj[1] ;
33037
33038 if (!args) SWIG_fail;
33039 swig_obj[0] = args;
33040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33041 if (!SWIG_IsOK(res1)) {
33042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33043 }
33044 arg1 = reinterpret_cast< wxWindow * >(argp1);
33045 {
33046 PyThreadState* __tstate = wxPyBeginAllowThreads();
33047 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33048 wxPyEndAllowThreads(__tstate);
33049 if (PyErr_Occurred()) SWIG_fail;
33050 }
33051 {
33052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33053 }
33054 return resultobj;
33055 fail:
33056 return NULL;
33057 }
33058
33059
33060 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33061 PyObject *resultobj = 0;
33062 wxWindow *arg1 = (wxWindow *) 0 ;
33063 bool result;
33064 void *argp1 = 0 ;
33065 int res1 = 0 ;
33066 PyObject *swig_obj[1] ;
33067
33068 if (!args) SWIG_fail;
33069 swig_obj[0] = args;
33070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33071 if (!SWIG_IsOK(res1)) {
33072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33073 }
33074 arg1 = reinterpret_cast< wxWindow * >(argp1);
33075 {
33076 PyThreadState* __tstate = wxPyBeginAllowThreads();
33077 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33078 wxPyEndAllowThreads(__tstate);
33079 if (PyErr_Occurred()) SWIG_fail;
33080 }
33081 {
33082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33083 }
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = 0;
33092 wxWindow *arg1 = (wxWindow *) 0 ;
33093 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33094 bool result;
33095 void *argp1 = 0 ;
33096 int res1 = 0 ;
33097 int val2 ;
33098 int ecode2 = 0 ;
33099 PyObject * obj0 = 0 ;
33100 PyObject * obj1 = 0 ;
33101 char * kwnames[] = {
33102 (char *) "self",(char *) "flags", NULL
33103 };
33104
33105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 if (obj1) {
33112 ecode2 = SWIG_AsVal_int(obj1, &val2);
33113 if (!SWIG_IsOK(ecode2)) {
33114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33115 }
33116 arg2 = static_cast< int >(val2);
33117 }
33118 {
33119 PyThreadState* __tstate = wxPyBeginAllowThreads();
33120 result = (bool)(arg1)->Navigate(arg2);
33121 wxPyEndAllowThreads(__tstate);
33122 if (PyErr_Occurred()) SWIG_fail;
33123 }
33124 {
33125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33126 }
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33134 PyObject *resultobj = 0;
33135 wxWindow *arg1 = (wxWindow *) 0 ;
33136 wxWindow *arg2 = (wxWindow *) 0 ;
33137 void *argp1 = 0 ;
33138 int res1 = 0 ;
33139 void *argp2 = 0 ;
33140 int res2 = 0 ;
33141 PyObject * obj0 = 0 ;
33142 PyObject * obj1 = 0 ;
33143 char * kwnames[] = {
33144 (char *) "self",(char *) "win", NULL
33145 };
33146
33147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33149 if (!SWIG_IsOK(res1)) {
33150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33151 }
33152 arg1 = reinterpret_cast< wxWindow * >(argp1);
33153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33154 if (!SWIG_IsOK(res2)) {
33155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33156 }
33157 arg2 = reinterpret_cast< wxWindow * >(argp2);
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 (arg1)->MoveAfterInTabOrder(arg2);
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 resultobj = SWIG_Py_Void();
33165 return resultobj;
33166 fail:
33167 return NULL;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33172 PyObject *resultobj = 0;
33173 wxWindow *arg1 = (wxWindow *) 0 ;
33174 wxWindow *arg2 = (wxWindow *) 0 ;
33175 void *argp1 = 0 ;
33176 int res1 = 0 ;
33177 void *argp2 = 0 ;
33178 int res2 = 0 ;
33179 PyObject * obj0 = 0 ;
33180 PyObject * obj1 = 0 ;
33181 char * kwnames[] = {
33182 (char *) "self",(char *) "win", NULL
33183 };
33184
33185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33187 if (!SWIG_IsOK(res1)) {
33188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33189 }
33190 arg1 = reinterpret_cast< wxWindow * >(argp1);
33191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res2)) {
33193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33194 }
33195 arg2 = reinterpret_cast< wxWindow * >(argp2);
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 (arg1)->MoveBeforeInTabOrder(arg2);
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 resultobj = SWIG_Py_Void();
33203 return resultobj;
33204 fail:
33205 return NULL;
33206 }
33207
33208
33209 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33210 PyObject *resultobj = 0;
33211 wxWindow *arg1 = (wxWindow *) 0 ;
33212 PyObject *result = 0 ;
33213 void *argp1 = 0 ;
33214 int res1 = 0 ;
33215 PyObject *swig_obj[1] ;
33216
33217 if (!args) SWIG_fail;
33218 swig_obj[0] = args;
33219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33220 if (!SWIG_IsOK(res1)) {
33221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33222 }
33223 arg1 = reinterpret_cast< wxWindow * >(argp1);
33224 {
33225 PyThreadState* __tstate = wxPyBeginAllowThreads();
33226 result = (PyObject *)wxWindow_GetChildren(arg1);
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 resultobj = result;
33231 return resultobj;
33232 fail:
33233 return NULL;
33234 }
33235
33236
33237 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33238 PyObject *resultobj = 0;
33239 wxWindow *arg1 = (wxWindow *) 0 ;
33240 wxWindow *result = 0 ;
33241 void *argp1 = 0 ;
33242 int res1 = 0 ;
33243 PyObject *swig_obj[1] ;
33244
33245 if (!args) SWIG_fail;
33246 swig_obj[0] = args;
33247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33248 if (!SWIG_IsOK(res1)) {
33249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33250 }
33251 arg1 = reinterpret_cast< wxWindow * >(argp1);
33252 {
33253 PyThreadState* __tstate = wxPyBeginAllowThreads();
33254 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 {
33259 resultobj = wxPyMake_wxObject(result, 0);
33260 }
33261 return resultobj;
33262 fail:
33263 return NULL;
33264 }
33265
33266
33267 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33268 PyObject *resultobj = 0;
33269 wxWindow *arg1 = (wxWindow *) 0 ;
33270 wxWindow *result = 0 ;
33271 void *argp1 = 0 ;
33272 int res1 = 0 ;
33273 PyObject *swig_obj[1] ;
33274
33275 if (!args) SWIG_fail;
33276 swig_obj[0] = args;
33277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33278 if (!SWIG_IsOK(res1)) {
33279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33280 }
33281 arg1 = reinterpret_cast< wxWindow * >(argp1);
33282 {
33283 PyThreadState* __tstate = wxPyBeginAllowThreads();
33284 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33285 wxPyEndAllowThreads(__tstate);
33286 if (PyErr_Occurred()) SWIG_fail;
33287 }
33288 {
33289 resultobj = wxPyMake_wxObject(result, 0);
33290 }
33291 return resultobj;
33292 fail:
33293 return NULL;
33294 }
33295
33296
33297 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33298 PyObject *resultobj = 0;
33299 wxWindow *arg1 = (wxWindow *) 0 ;
33300 bool result;
33301 void *argp1 = 0 ;
33302 int res1 = 0 ;
33303 PyObject *swig_obj[1] ;
33304
33305 if (!args) SWIG_fail;
33306 swig_obj[0] = args;
33307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33308 if (!SWIG_IsOK(res1)) {
33309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33310 }
33311 arg1 = reinterpret_cast< wxWindow * >(argp1);
33312 {
33313 PyThreadState* __tstate = wxPyBeginAllowThreads();
33314 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33315 wxPyEndAllowThreads(__tstate);
33316 if (PyErr_Occurred()) SWIG_fail;
33317 }
33318 {
33319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33320 }
33321 return resultobj;
33322 fail:
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 wxWindow *arg1 = (wxWindow *) 0 ;
33330 wxWindow *arg2 = (wxWindow *) 0 ;
33331 bool result;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 void *argp2 = 0 ;
33335 int res2 = 0 ;
33336 PyObject * obj0 = 0 ;
33337 PyObject * obj1 = 0 ;
33338 char * kwnames[] = {
33339 (char *) "self",(char *) "newParent", NULL
33340 };
33341
33342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33344 if (!SWIG_IsOK(res1)) {
33345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33346 }
33347 arg1 = reinterpret_cast< wxWindow * >(argp1);
33348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33349 if (!SWIG_IsOK(res2)) {
33350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33351 }
33352 arg2 = reinterpret_cast< wxWindow * >(argp2);
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = (bool)(arg1)->Reparent(arg2);
33356 wxPyEndAllowThreads(__tstate);
33357 if (PyErr_Occurred()) SWIG_fail;
33358 }
33359 {
33360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33361 }
33362 return resultobj;
33363 fail:
33364 return NULL;
33365 }
33366
33367
33368 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33369 PyObject *resultobj = 0;
33370 wxWindow *arg1 = (wxWindow *) 0 ;
33371 wxWindow *arg2 = (wxWindow *) 0 ;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374 void *argp2 = 0 ;
33375 int res2 = 0 ;
33376 PyObject * obj0 = 0 ;
33377 PyObject * obj1 = 0 ;
33378 char * kwnames[] = {
33379 (char *) "self",(char *) "child", NULL
33380 };
33381
33382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33386 }
33387 arg1 = reinterpret_cast< wxWindow * >(argp1);
33388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33389 if (!SWIG_IsOK(res2)) {
33390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33391 }
33392 arg2 = reinterpret_cast< wxWindow * >(argp2);
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 (arg1)->AddChild(arg2);
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 resultobj = SWIG_Py_Void();
33400 return resultobj;
33401 fail:
33402 return NULL;
33403 }
33404
33405
33406 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33407 PyObject *resultobj = 0;
33408 wxWindow *arg1 = (wxWindow *) 0 ;
33409 wxWindow *arg2 = (wxWindow *) 0 ;
33410 void *argp1 = 0 ;
33411 int res1 = 0 ;
33412 void *argp2 = 0 ;
33413 int res2 = 0 ;
33414 PyObject * obj0 = 0 ;
33415 PyObject * obj1 = 0 ;
33416 char * kwnames[] = {
33417 (char *) "self",(char *) "child", NULL
33418 };
33419
33420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33422 if (!SWIG_IsOK(res1)) {
33423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33424 }
33425 arg1 = reinterpret_cast< wxWindow * >(argp1);
33426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33427 if (!SWIG_IsOK(res2)) {
33428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33429 }
33430 arg2 = reinterpret_cast< wxWindow * >(argp2);
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 (arg1)->RemoveChild(arg2);
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 resultobj = SWIG_Py_Void();
33438 return resultobj;
33439 fail:
33440 return NULL;
33441 }
33442
33443
33444 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33445 PyObject *resultobj = 0;
33446 wxWindow *arg1 = (wxWindow *) 0 ;
33447 bool arg2 ;
33448 void *argp1 = 0 ;
33449 int res1 = 0 ;
33450 bool val2 ;
33451 int ecode2 = 0 ;
33452 PyObject * obj0 = 0 ;
33453 PyObject * obj1 = 0 ;
33454 char * kwnames[] = {
33455 (char *) "self",(char *) "on", NULL
33456 };
33457
33458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33460 if (!SWIG_IsOK(res1)) {
33461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33462 }
33463 arg1 = reinterpret_cast< wxWindow * >(argp1);
33464 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33465 if (!SWIG_IsOK(ecode2)) {
33466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33467 }
33468 arg2 = static_cast< bool >(val2);
33469 {
33470 PyThreadState* __tstate = wxPyBeginAllowThreads();
33471 (arg1)->SetDoubleBuffered(arg2);
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 resultobj = SWIG_Py_Void();
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33483 PyObject *resultobj = 0;
33484 wxWindow *arg1 = (wxWindow *) 0 ;
33485 long arg2 ;
33486 wxWindow *result = 0 ;
33487 void *argp1 = 0 ;
33488 int res1 = 0 ;
33489 long val2 ;
33490 int ecode2 = 0 ;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 char * kwnames[] = {
33494 (char *) "self",(char *) "winid", NULL
33495 };
33496
33497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33499 if (!SWIG_IsOK(res1)) {
33500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33501 }
33502 arg1 = reinterpret_cast< wxWindow * >(argp1);
33503 ecode2 = SWIG_AsVal_long(obj1, &val2);
33504 if (!SWIG_IsOK(ecode2)) {
33505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33506 }
33507 arg2 = static_cast< long >(val2);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (wxWindow *)(arg1)->FindWindow(arg2);
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = wxPyMake_wxObject(result, 0);
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 wxString *arg2 = 0 ;
33527 wxWindow *result = 0 ;
33528 void *argp1 = 0 ;
33529 int res1 = 0 ;
33530 bool temp2 = false ;
33531 PyObject * obj0 = 0 ;
33532 PyObject * obj1 = 0 ;
33533 char * kwnames[] = {
33534 (char *) "self",(char *) "name", NULL
33535 };
33536
33537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33539 if (!SWIG_IsOK(res1)) {
33540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33541 }
33542 arg1 = reinterpret_cast< wxWindow * >(argp1);
33543 {
33544 arg2 = wxString_in_helper(obj1);
33545 if (arg2 == NULL) SWIG_fail;
33546 temp2 = true;
33547 }
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 {
33555 resultobj = wxPyMake_wxObject(result, 0);
33556 }
33557 {
33558 if (temp2)
33559 delete arg2;
33560 }
33561 return resultobj;
33562 fail:
33563 {
33564 if (temp2)
33565 delete arg2;
33566 }
33567 return NULL;
33568 }
33569
33570
33571 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33572 PyObject *resultobj = 0;
33573 wxWindow *arg1 = (wxWindow *) 0 ;
33574 wxEvtHandler *result = 0 ;
33575 void *argp1 = 0 ;
33576 int res1 = 0 ;
33577 PyObject *swig_obj[1] ;
33578
33579 if (!args) SWIG_fail;
33580 swig_obj[0] = args;
33581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33582 if (!SWIG_IsOK(res1)) {
33583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33584 }
33585 arg1 = reinterpret_cast< wxWindow * >(argp1);
33586 {
33587 PyThreadState* __tstate = wxPyBeginAllowThreads();
33588 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 {
33593 resultobj = wxPyMake_wxObject(result, 0);
33594 }
33595 return resultobj;
33596 fail:
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33602 PyObject *resultobj = 0;
33603 wxWindow *arg1 = (wxWindow *) 0 ;
33604 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 void *argp2 = 0 ;
33608 int res2 = 0 ;
33609 PyObject * obj0 = 0 ;
33610 PyObject * obj1 = 0 ;
33611 char * kwnames[] = {
33612 (char *) "self",(char *) "handler", NULL
33613 };
33614
33615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33617 if (!SWIG_IsOK(res1)) {
33618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33619 }
33620 arg1 = reinterpret_cast< wxWindow * >(argp1);
33621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33622 if (!SWIG_IsOK(res2)) {
33623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33624 }
33625 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33626 {
33627 PyThreadState* __tstate = wxPyBeginAllowThreads();
33628 (arg1)->SetEventHandler(arg2);
33629 wxPyEndAllowThreads(__tstate);
33630 if (PyErr_Occurred()) SWIG_fail;
33631 }
33632 resultobj = SWIG_Py_Void();
33633 return resultobj;
33634 fail:
33635 return NULL;
33636 }
33637
33638
33639 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33640 PyObject *resultobj = 0;
33641 wxWindow *arg1 = (wxWindow *) 0 ;
33642 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33643 void *argp1 = 0 ;
33644 int res1 = 0 ;
33645 void *argp2 = 0 ;
33646 int res2 = 0 ;
33647 PyObject * obj0 = 0 ;
33648 PyObject * obj1 = 0 ;
33649 char * kwnames[] = {
33650 (char *) "self",(char *) "handler", NULL
33651 };
33652
33653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33657 }
33658 arg1 = reinterpret_cast< wxWindow * >(argp1);
33659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33660 if (!SWIG_IsOK(res2)) {
33661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33662 }
33663 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33664 {
33665 PyThreadState* __tstate = wxPyBeginAllowThreads();
33666 (arg1)->PushEventHandler(arg2);
33667 wxPyEndAllowThreads(__tstate);
33668 if (PyErr_Occurred()) SWIG_fail;
33669 }
33670 resultobj = SWIG_Py_Void();
33671 return resultobj;
33672 fail:
33673 return NULL;
33674 }
33675
33676
33677 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33678 PyObject *resultobj = 0;
33679 wxWindow *arg1 = (wxWindow *) 0 ;
33680 bool arg2 = (bool) false ;
33681 wxEvtHandler *result = 0 ;
33682 void *argp1 = 0 ;
33683 int res1 = 0 ;
33684 bool val2 ;
33685 int ecode2 = 0 ;
33686 PyObject * obj0 = 0 ;
33687 PyObject * obj1 = 0 ;
33688 char * kwnames[] = {
33689 (char *) "self",(char *) "deleteHandler", NULL
33690 };
33691
33692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33694 if (!SWIG_IsOK(res1)) {
33695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33696 }
33697 arg1 = reinterpret_cast< wxWindow * >(argp1);
33698 if (obj1) {
33699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33700 if (!SWIG_IsOK(ecode2)) {
33701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33702 }
33703 arg2 = static_cast< bool >(val2);
33704 }
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 {
33712 resultobj = wxPyMake_wxObject(result, 0);
33713 }
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33724 bool result;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 void *argp2 = 0 ;
33728 int res2 = 0 ;
33729 PyObject * obj0 = 0 ;
33730 PyObject * obj1 = 0 ;
33731 char * kwnames[] = {
33732 (char *) "self",(char *) "handler", NULL
33733 };
33734
33735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33737 if (!SWIG_IsOK(res1)) {
33738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33739 }
33740 arg1 = reinterpret_cast< wxWindow * >(argp1);
33741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33742 if (!SWIG_IsOK(res2)) {
33743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33744 }
33745 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33746 {
33747 PyThreadState* __tstate = wxPyBeginAllowThreads();
33748 result = (bool)(arg1)->RemoveEventHandler(arg2);
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 {
33753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33754 }
33755 return resultobj;
33756 fail:
33757 return NULL;
33758 }
33759
33760
33761 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33762 PyObject *resultobj = 0;
33763 wxWindow *arg1 = (wxWindow *) 0 ;
33764 wxValidator *arg2 = 0 ;
33765 void *argp1 = 0 ;
33766 int res1 = 0 ;
33767 void *argp2 = 0 ;
33768 int res2 = 0 ;
33769 PyObject * obj0 = 0 ;
33770 PyObject * obj1 = 0 ;
33771 char * kwnames[] = {
33772 (char *) "self",(char *) "validator", NULL
33773 };
33774
33775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33777 if (!SWIG_IsOK(res1)) {
33778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33779 }
33780 arg1 = reinterpret_cast< wxWindow * >(argp1);
33781 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33782 if (!SWIG_IsOK(res2)) {
33783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33784 }
33785 if (!argp2) {
33786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33787 }
33788 arg2 = reinterpret_cast< wxValidator * >(argp2);
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 (arg1)->SetValidator((wxValidator const &)*arg2);
33792 wxPyEndAllowThreads(__tstate);
33793 if (PyErr_Occurred()) SWIG_fail;
33794 }
33795 resultobj = SWIG_Py_Void();
33796 return resultobj;
33797 fail:
33798 return NULL;
33799 }
33800
33801
33802 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33803 PyObject *resultobj = 0;
33804 wxWindow *arg1 = (wxWindow *) 0 ;
33805 wxValidator *result = 0 ;
33806 void *argp1 = 0 ;
33807 int res1 = 0 ;
33808 PyObject *swig_obj[1] ;
33809
33810 if (!args) SWIG_fail;
33811 swig_obj[0] = args;
33812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33813 if (!SWIG_IsOK(res1)) {
33814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33815 }
33816 arg1 = reinterpret_cast< wxWindow * >(argp1);
33817 {
33818 PyThreadState* __tstate = wxPyBeginAllowThreads();
33819 result = (wxValidator *)(arg1)->GetValidator();
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 {
33824 resultobj = wxPyMake_wxObject(result, (bool)0);
33825 }
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33833 PyObject *resultobj = 0;
33834 wxWindow *arg1 = (wxWindow *) 0 ;
33835 bool result;
33836 void *argp1 = 0 ;
33837 int res1 = 0 ;
33838 PyObject *swig_obj[1] ;
33839
33840 if (!args) SWIG_fail;
33841 swig_obj[0] = args;
33842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33843 if (!SWIG_IsOK(res1)) {
33844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33845 }
33846 arg1 = reinterpret_cast< wxWindow * >(argp1);
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 result = (bool)(arg1)->Validate();
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 {
33854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33855 }
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 bool result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 PyObject *swig_obj[1] ;
33869
33870 if (!args) SWIG_fail;
33871 swig_obj[0] = args;
33872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33873 if (!SWIG_IsOK(res1)) {
33874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33875 }
33876 arg1 = reinterpret_cast< wxWindow * >(argp1);
33877 {
33878 PyThreadState* __tstate = wxPyBeginAllowThreads();
33879 result = (bool)(arg1)->TransferDataToWindow();
33880 wxPyEndAllowThreads(__tstate);
33881 if (PyErr_Occurred()) SWIG_fail;
33882 }
33883 {
33884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33885 }
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33893 PyObject *resultobj = 0;
33894 wxWindow *arg1 = (wxWindow *) 0 ;
33895 bool result;
33896 void *argp1 = 0 ;
33897 int res1 = 0 ;
33898 PyObject *swig_obj[1] ;
33899
33900 if (!args) SWIG_fail;
33901 swig_obj[0] = args;
33902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33905 }
33906 arg1 = reinterpret_cast< wxWindow * >(argp1);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (bool)(arg1)->TransferDataFromWindow();
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 {
33914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33915 }
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33923 PyObject *resultobj = 0;
33924 wxWindow *arg1 = (wxWindow *) 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 PyObject *swig_obj[1] ;
33928
33929 if (!args) SWIG_fail;
33930 swig_obj[0] = args;
33931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33932 if (!SWIG_IsOK(res1)) {
33933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33934 }
33935 arg1 = reinterpret_cast< wxWindow * >(argp1);
33936 {
33937 PyThreadState* __tstate = wxPyBeginAllowThreads();
33938 (arg1)->InitDialog();
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 resultobj = SWIG_Py_Void();
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj = 0;
33951 wxWindow *arg1 = (wxWindow *) 0 ;
33952 wxAcceleratorTable *arg2 = 0 ;
33953 void *argp1 = 0 ;
33954 int res1 = 0 ;
33955 void *argp2 = 0 ;
33956 int res2 = 0 ;
33957 PyObject * obj0 = 0 ;
33958 PyObject * obj1 = 0 ;
33959 char * kwnames[] = {
33960 (char *) "self",(char *) "accel", NULL
33961 };
33962
33963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33965 if (!SWIG_IsOK(res1)) {
33966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33967 }
33968 arg1 = reinterpret_cast< wxWindow * >(argp1);
33969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33970 if (!SWIG_IsOK(res2)) {
33971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33972 }
33973 if (!argp2) {
33974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33975 }
33976 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33980 wxPyEndAllowThreads(__tstate);
33981 if (PyErr_Occurred()) SWIG_fail;
33982 }
33983 resultobj = SWIG_Py_Void();
33984 return resultobj;
33985 fail:
33986 return NULL;
33987 }
33988
33989
33990 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33991 PyObject *resultobj = 0;
33992 wxWindow *arg1 = (wxWindow *) 0 ;
33993 wxAcceleratorTable *result = 0 ;
33994 void *argp1 = 0 ;
33995 int res1 = 0 ;
33996 PyObject *swig_obj[1] ;
33997
33998 if (!args) SWIG_fail;
33999 swig_obj[0] = args;
34000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34003 }
34004 arg1 = reinterpret_cast< wxWindow * >(argp1);
34005 {
34006 PyThreadState* __tstate = wxPyBeginAllowThreads();
34007 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj = 0;
34020 wxWindow *arg1 = (wxWindow *) 0 ;
34021 int arg2 ;
34022 int arg3 ;
34023 int arg4 ;
34024 bool result;
34025 void *argp1 = 0 ;
34026 int res1 = 0 ;
34027 int val2 ;
34028 int ecode2 = 0 ;
34029 int val3 ;
34030 int ecode3 = 0 ;
34031 int val4 ;
34032 int ecode4 = 0 ;
34033 PyObject * obj0 = 0 ;
34034 PyObject * obj1 = 0 ;
34035 PyObject * obj2 = 0 ;
34036 PyObject * obj3 = 0 ;
34037 char * kwnames[] = {
34038 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34039 };
34040
34041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34043 if (!SWIG_IsOK(res1)) {
34044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34045 }
34046 arg1 = reinterpret_cast< wxWindow * >(argp1);
34047 ecode2 = SWIG_AsVal_int(obj1, &val2);
34048 if (!SWIG_IsOK(ecode2)) {
34049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34050 }
34051 arg2 = static_cast< int >(val2);
34052 ecode3 = SWIG_AsVal_int(obj2, &val3);
34053 if (!SWIG_IsOK(ecode3)) {
34054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34055 }
34056 arg3 = static_cast< int >(val3);
34057 ecode4 = SWIG_AsVal_int(obj3, &val4);
34058 if (!SWIG_IsOK(ecode4)) {
34059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34060 }
34061 arg4 = static_cast< int >(val4);
34062 {
34063 PyThreadState* __tstate = wxPyBeginAllowThreads();
34064 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34065 wxPyEndAllowThreads(__tstate);
34066 if (PyErr_Occurred()) SWIG_fail;
34067 }
34068 {
34069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34070 }
34071 return resultobj;
34072 fail:
34073 return NULL;
34074 }
34075
34076
34077 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34078 PyObject *resultobj = 0;
34079 wxWindow *arg1 = (wxWindow *) 0 ;
34080 int arg2 ;
34081 bool result;
34082 void *argp1 = 0 ;
34083 int res1 = 0 ;
34084 int val2 ;
34085 int ecode2 = 0 ;
34086 PyObject * obj0 = 0 ;
34087 PyObject * obj1 = 0 ;
34088 char * kwnames[] = {
34089 (char *) "self",(char *) "hotkeyId", NULL
34090 };
34091
34092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34094 if (!SWIG_IsOK(res1)) {
34095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34096 }
34097 arg1 = reinterpret_cast< wxWindow * >(argp1);
34098 ecode2 = SWIG_AsVal_int(obj1, &val2);
34099 if (!SWIG_IsOK(ecode2)) {
34100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34101 }
34102 arg2 = static_cast< int >(val2);
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34106 wxPyEndAllowThreads(__tstate);
34107 if (PyErr_Occurred()) SWIG_fail;
34108 }
34109 {
34110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34111 }
34112 return resultobj;
34113 fail:
34114 return NULL;
34115 }
34116
34117
34118 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj = 0;
34120 wxWindow *arg1 = (wxWindow *) 0 ;
34121 wxPoint *arg2 = 0 ;
34122 wxPoint result;
34123 void *argp1 = 0 ;
34124 int res1 = 0 ;
34125 wxPoint temp2 ;
34126 PyObject * obj0 = 0 ;
34127 PyObject * obj1 = 0 ;
34128 char * kwnames[] = {
34129 (char *) "self",(char *) "pt", NULL
34130 };
34131
34132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34134 if (!SWIG_IsOK(res1)) {
34135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34136 }
34137 arg1 = reinterpret_cast< wxWindow * >(argp1);
34138 {
34139 arg2 = &temp2;
34140 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34141 }
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = 0;
34157 wxWindow *arg1 = (wxWindow *) 0 ;
34158 wxSize *arg2 = 0 ;
34159 wxSize result;
34160 void *argp1 = 0 ;
34161 int res1 = 0 ;
34162 wxSize temp2 ;
34163 PyObject * obj0 = 0 ;
34164 PyObject * obj1 = 0 ;
34165 char * kwnames[] = {
34166 (char *) "self",(char *) "sz", NULL
34167 };
34168
34169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34171 if (!SWIG_IsOK(res1)) {
34172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34173 }
34174 arg1 = reinterpret_cast< wxWindow * >(argp1);
34175 {
34176 arg2 = &temp2;
34177 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34178 }
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34186 return resultobj;
34187 fail:
34188 return NULL;
34189 }
34190
34191
34192 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34193 PyObject *resultobj = 0;
34194 wxWindow *arg1 = (wxWindow *) 0 ;
34195 wxPoint *arg2 = 0 ;
34196 wxPoint result;
34197 void *argp1 = 0 ;
34198 int res1 = 0 ;
34199 wxPoint temp2 ;
34200 PyObject * obj0 = 0 ;
34201 PyObject * obj1 = 0 ;
34202 char * kwnames[] = {
34203 (char *) "self",(char *) "pt", NULL
34204 };
34205
34206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 arg2 = &temp2;
34214 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34215 }
34216 {
34217 PyThreadState* __tstate = wxPyBeginAllowThreads();
34218 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34219 wxPyEndAllowThreads(__tstate);
34220 if (PyErr_Occurred()) SWIG_fail;
34221 }
34222 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34223 return resultobj;
34224 fail:
34225 return NULL;
34226 }
34227
34228
34229 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34230 PyObject *resultobj = 0;
34231 wxWindow *arg1 = (wxWindow *) 0 ;
34232 wxSize *arg2 = 0 ;
34233 wxSize result;
34234 void *argp1 = 0 ;
34235 int res1 = 0 ;
34236 wxSize temp2 ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 char * kwnames[] = {
34240 (char *) "self",(char *) "sz", NULL
34241 };
34242
34243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34245 if (!SWIG_IsOK(res1)) {
34246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34247 }
34248 arg1 = reinterpret_cast< wxWindow * >(argp1);
34249 {
34250 arg2 = &temp2;
34251 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34252 }
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34267 PyObject *resultobj = 0;
34268 wxWindow *arg1 = (wxWindow *) 0 ;
34269 wxPoint *arg2 = 0 ;
34270 wxPoint result;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 wxPoint temp2 ;
34274 PyObject * obj0 = 0 ;
34275 PyObject * obj1 = 0 ;
34276 char * kwnames[] = {
34277 (char *) "self",(char *) "pt", NULL
34278 };
34279
34280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34282 if (!SWIG_IsOK(res1)) {
34283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34284 }
34285 arg1 = reinterpret_cast< wxWindow * >(argp1);
34286 {
34287 arg2 = &temp2;
34288 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34289 }
34290 {
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34304 PyObject *resultobj = 0;
34305 wxWindow *arg1 = (wxWindow *) 0 ;
34306 wxSize *arg2 = 0 ;
34307 wxSize result;
34308 void *argp1 = 0 ;
34309 int res1 = 0 ;
34310 wxSize temp2 ;
34311 PyObject * obj0 = 0 ;
34312 PyObject * obj1 = 0 ;
34313 char * kwnames[] = {
34314 (char *) "self",(char *) "sz", NULL
34315 };
34316
34317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res1)) {
34320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34321 }
34322 arg1 = reinterpret_cast< wxWindow * >(argp1);
34323 {
34324 arg2 = &temp2;
34325 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34326 }
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34341 PyObject *resultobj = 0;
34342 wxWindow *arg1 = (wxWindow *) 0 ;
34343 int arg2 ;
34344 int arg3 ;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 int val2 ;
34348 int ecode2 = 0 ;
34349 int val3 ;
34350 int ecode3 = 0 ;
34351 PyObject * obj0 = 0 ;
34352 PyObject * obj1 = 0 ;
34353 PyObject * obj2 = 0 ;
34354 char * kwnames[] = {
34355 (char *) "self",(char *) "x",(char *) "y", NULL
34356 };
34357
34358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 ecode2 = SWIG_AsVal_int(obj1, &val2);
34365 if (!SWIG_IsOK(ecode2)) {
34366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34367 }
34368 arg2 = static_cast< int >(val2);
34369 ecode3 = SWIG_AsVal_int(obj2, &val3);
34370 if (!SWIG_IsOK(ecode3)) {
34371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34372 }
34373 arg3 = static_cast< int >(val3);
34374 {
34375 PyThreadState* __tstate = wxPyBeginAllowThreads();
34376 (arg1)->WarpPointer(arg2,arg3);
34377 wxPyEndAllowThreads(__tstate);
34378 if (PyErr_Occurred()) SWIG_fail;
34379 }
34380 resultobj = SWIG_Py_Void();
34381 return resultobj;
34382 fail:
34383 return NULL;
34384 }
34385
34386
34387 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34388 PyObject *resultobj = 0;
34389 wxWindow *arg1 = (wxWindow *) 0 ;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 (arg1)->CaptureMouse();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_Py_Void();
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 void *argp1 = 0 ;
34418 int res1 = 0 ;
34419 PyObject *swig_obj[1] ;
34420
34421 if (!args) SWIG_fail;
34422 swig_obj[0] = args;
34423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34424 if (!SWIG_IsOK(res1)) {
34425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34426 }
34427 arg1 = reinterpret_cast< wxWindow * >(argp1);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 (arg1)->ReleaseMouse();
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 resultobj = SWIG_Py_Void();
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34442 PyObject *resultobj = 0;
34443 wxWindow *result = 0 ;
34444
34445 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34446 {
34447 if (!wxPyCheckForApp()) SWIG_fail;
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 result = (wxWindow *)wxWindow::GetCapture();
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 {
34454 resultobj = wxPyMake_wxObject(result, 0);
34455 }
34456 return resultobj;
34457 fail:
34458 return NULL;
34459 }
34460
34461
34462 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34463 PyObject *resultobj = 0;
34464 wxWindow *arg1 = (wxWindow *) 0 ;
34465 bool result;
34466 void *argp1 = 0 ;
34467 int res1 = 0 ;
34468 PyObject *swig_obj[1] ;
34469
34470 if (!args) SWIG_fail;
34471 swig_obj[0] = args;
34472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 result = (bool)((wxWindow const *)arg1)->HasCapture();
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 {
34484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34485 }
34486 return resultobj;
34487 fail:
34488 return NULL;
34489 }
34490
34491
34492 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34493 PyObject *resultobj = 0;
34494 wxWindow *arg1 = (wxWindow *) 0 ;
34495 bool arg2 = (bool) true ;
34496 wxRect *arg3 = (wxRect *) NULL ;
34497 void *argp1 = 0 ;
34498 int res1 = 0 ;
34499 bool val2 ;
34500 int ecode2 = 0 ;
34501 void *argp3 = 0 ;
34502 int res3 = 0 ;
34503 PyObject * obj0 = 0 ;
34504 PyObject * obj1 = 0 ;
34505 PyObject * obj2 = 0 ;
34506 char * kwnames[] = {
34507 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34508 };
34509
34510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34512 if (!SWIG_IsOK(res1)) {
34513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34514 }
34515 arg1 = reinterpret_cast< wxWindow * >(argp1);
34516 if (obj1) {
34517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34518 if (!SWIG_IsOK(ecode2)) {
34519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34520 }
34521 arg2 = static_cast< bool >(val2);
34522 }
34523 if (obj2) {
34524 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34525 if (!SWIG_IsOK(res3)) {
34526 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34527 }
34528 arg3 = reinterpret_cast< wxRect * >(argp3);
34529 }
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34533 wxPyEndAllowThreads(__tstate);
34534 if (PyErr_Occurred()) SWIG_fail;
34535 }
34536 resultobj = SWIG_Py_Void();
34537 return resultobj;
34538 fail:
34539 return NULL;
34540 }
34541
34542
34543 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34544 PyObject *resultobj = 0;
34545 wxWindow *arg1 = (wxWindow *) 0 ;
34546 wxRect *arg2 = 0 ;
34547 bool arg3 = (bool) true ;
34548 void *argp1 = 0 ;
34549 int res1 = 0 ;
34550 wxRect temp2 ;
34551 bool val3 ;
34552 int ecode3 = 0 ;
34553 PyObject * obj0 = 0 ;
34554 PyObject * obj1 = 0 ;
34555 PyObject * obj2 = 0 ;
34556 char * kwnames[] = {
34557 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34558 };
34559
34560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34562 if (!SWIG_IsOK(res1)) {
34563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34564 }
34565 arg1 = reinterpret_cast< wxWindow * >(argp1);
34566 {
34567 arg2 = &temp2;
34568 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34569 }
34570 if (obj2) {
34571 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34572 if (!SWIG_IsOK(ecode3)) {
34573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34574 }
34575 arg3 = static_cast< bool >(val3);
34576 }
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 resultobj = SWIG_Py_Void();
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34591 PyObject *resultobj = 0;
34592 wxWindow *arg1 = (wxWindow *) 0 ;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 PyObject *swig_obj[1] ;
34596
34597 if (!args) SWIG_fail;
34598 swig_obj[0] = args;
34599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34600 if (!SWIG_IsOK(res1)) {
34601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34602 }
34603 arg1 = reinterpret_cast< wxWindow * >(argp1);
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 (arg1)->Update();
34607 wxPyEndAllowThreads(__tstate);
34608 if (PyErr_Occurred()) SWIG_fail;
34609 }
34610 resultobj = SWIG_Py_Void();
34611 return resultobj;
34612 fail:
34613 return NULL;
34614 }
34615
34616
34617 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34618 PyObject *resultobj = 0;
34619 wxWindow *arg1 = (wxWindow *) 0 ;
34620 void *argp1 = 0 ;
34621 int res1 = 0 ;
34622 PyObject *swig_obj[1] ;
34623
34624 if (!args) SWIG_fail;
34625 swig_obj[0] = args;
34626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34627 if (!SWIG_IsOK(res1)) {
34628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34629 }
34630 arg1 = reinterpret_cast< wxWindow * >(argp1);
34631 {
34632 PyThreadState* __tstate = wxPyBeginAllowThreads();
34633 (arg1)->ClearBackground();
34634 wxPyEndAllowThreads(__tstate);
34635 if (PyErr_Occurred()) SWIG_fail;
34636 }
34637 resultobj = SWIG_Py_Void();
34638 return resultobj;
34639 fail:
34640 return NULL;
34641 }
34642
34643
34644 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34645 PyObject *resultobj = 0;
34646 wxWindow *arg1 = (wxWindow *) 0 ;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 PyObject *swig_obj[1] ;
34650
34651 if (!args) SWIG_fail;
34652 swig_obj[0] = args;
34653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34654 if (!SWIG_IsOK(res1)) {
34655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34656 }
34657 arg1 = reinterpret_cast< wxWindow * >(argp1);
34658 {
34659 PyThreadState* __tstate = wxPyBeginAllowThreads();
34660 (arg1)->Freeze();
34661 wxPyEndAllowThreads(__tstate);
34662 if (PyErr_Occurred()) SWIG_fail;
34663 }
34664 resultobj = SWIG_Py_Void();
34665 return resultobj;
34666 fail:
34667 return NULL;
34668 }
34669
34670
34671 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34672 PyObject *resultobj = 0;
34673 wxWindow *arg1 = (wxWindow *) 0 ;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 PyObject *swig_obj[1] ;
34677
34678 if (!args) SWIG_fail;
34679 swig_obj[0] = args;
34680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34681 if (!SWIG_IsOK(res1)) {
34682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34683 }
34684 arg1 = reinterpret_cast< wxWindow * >(argp1);
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 (arg1)->Thaw();
34688 wxPyEndAllowThreads(__tstate);
34689 if (PyErr_Occurred()) SWIG_fail;
34690 }
34691 resultobj = SWIG_Py_Void();
34692 return resultobj;
34693 fail:
34694 return NULL;
34695 }
34696
34697
34698 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34699 PyObject *resultobj = 0;
34700 wxWindow *arg1 = (wxWindow *) 0 ;
34701 wxDC *arg2 = 0 ;
34702 void *argp1 = 0 ;
34703 int res1 = 0 ;
34704 void *argp2 = 0 ;
34705 int res2 = 0 ;
34706 PyObject * obj0 = 0 ;
34707 PyObject * obj1 = 0 ;
34708 char * kwnames[] = {
34709 (char *) "self",(char *) "dc", NULL
34710 };
34711
34712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34714 if (!SWIG_IsOK(res1)) {
34715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34716 }
34717 arg1 = reinterpret_cast< wxWindow * >(argp1);
34718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34719 if (!SWIG_IsOK(res2)) {
34720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34721 }
34722 if (!argp2) {
34723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34724 }
34725 arg2 = reinterpret_cast< wxDC * >(argp2);
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 (arg1)->PrepareDC(*arg2);
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 resultobj = SWIG_Py_Void();
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34740 PyObject *resultobj = 0;
34741 wxWindow *arg1 = (wxWindow *) 0 ;
34742 wxRegion *result = 0 ;
34743 void *argp1 = 0 ;
34744 int res1 = 0 ;
34745 PyObject *swig_obj[1] ;
34746
34747 if (!args) SWIG_fail;
34748 swig_obj[0] = args;
34749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 {
34757 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34758 result = (wxRegion *) &_result_ref;
34759 }
34760 wxPyEndAllowThreads(__tstate);
34761 if (PyErr_Occurred()) SWIG_fail;
34762 }
34763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34764 return resultobj;
34765 fail:
34766 return NULL;
34767 }
34768
34769
34770 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34771 PyObject *resultobj = 0;
34772 wxWindow *arg1 = (wxWindow *) 0 ;
34773 wxRect result;
34774 void *argp1 = 0 ;
34775 int res1 = 0 ;
34776 PyObject *swig_obj[1] ;
34777
34778 if (!args) SWIG_fail;
34779 swig_obj[0] = args;
34780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34783 }
34784 arg1 = reinterpret_cast< wxWindow * >(argp1);
34785 {
34786 PyThreadState* __tstate = wxPyBeginAllowThreads();
34787 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34788 wxPyEndAllowThreads(__tstate);
34789 if (PyErr_Occurred()) SWIG_fail;
34790 }
34791 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34792 return resultobj;
34793 fail:
34794 return NULL;
34795 }
34796
34797
34798 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34799 PyObject *resultobj = 0;
34800 wxWindow *arg1 = (wxWindow *) 0 ;
34801 int arg2 ;
34802 int arg3 ;
34803 int arg4 = (int) 1 ;
34804 int arg5 = (int) 1 ;
34805 bool result;
34806 void *argp1 = 0 ;
34807 int res1 = 0 ;
34808 int val2 ;
34809 int ecode2 = 0 ;
34810 int val3 ;
34811 int ecode3 = 0 ;
34812 int val4 ;
34813 int ecode4 = 0 ;
34814 int val5 ;
34815 int ecode5 = 0 ;
34816 PyObject * obj0 = 0 ;
34817 PyObject * obj1 = 0 ;
34818 PyObject * obj2 = 0 ;
34819 PyObject * obj3 = 0 ;
34820 PyObject * obj4 = 0 ;
34821 char * kwnames[] = {
34822 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34823 };
34824
34825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34827 if (!SWIG_IsOK(res1)) {
34828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34829 }
34830 arg1 = reinterpret_cast< wxWindow * >(argp1);
34831 ecode2 = SWIG_AsVal_int(obj1, &val2);
34832 if (!SWIG_IsOK(ecode2)) {
34833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34834 }
34835 arg2 = static_cast< int >(val2);
34836 ecode3 = SWIG_AsVal_int(obj2, &val3);
34837 if (!SWIG_IsOK(ecode3)) {
34838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34839 }
34840 arg3 = static_cast< int >(val3);
34841 if (obj3) {
34842 ecode4 = SWIG_AsVal_int(obj3, &val4);
34843 if (!SWIG_IsOK(ecode4)) {
34844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34845 }
34846 arg4 = static_cast< int >(val4);
34847 }
34848 if (obj4) {
34849 ecode5 = SWIG_AsVal_int(obj4, &val5);
34850 if (!SWIG_IsOK(ecode5)) {
34851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34852 }
34853 arg5 = static_cast< int >(val5);
34854 }
34855 {
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 {
34862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34863 }
34864 return resultobj;
34865 fail:
34866 return NULL;
34867 }
34868
34869
34870 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34871 PyObject *resultobj = 0;
34872 wxWindow *arg1 = (wxWindow *) 0 ;
34873 wxPoint *arg2 = 0 ;
34874 bool result;
34875 void *argp1 = 0 ;
34876 int res1 = 0 ;
34877 wxPoint temp2 ;
34878 PyObject * obj0 = 0 ;
34879 PyObject * obj1 = 0 ;
34880 char * kwnames[] = {
34881 (char *) "self",(char *) "pt", NULL
34882 };
34883
34884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34886 if (!SWIG_IsOK(res1)) {
34887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34888 }
34889 arg1 = reinterpret_cast< wxWindow * >(argp1);
34890 {
34891 arg2 = &temp2;
34892 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34893 }
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34897 wxPyEndAllowThreads(__tstate);
34898 if (PyErr_Occurred()) SWIG_fail;
34899 }
34900 {
34901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34902 }
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = 0;
34911 wxWindow *arg1 = (wxWindow *) 0 ;
34912 wxRect *arg2 = 0 ;
34913 bool result;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 wxRect temp2 ;
34917 PyObject * obj0 = 0 ;
34918 PyObject * obj1 = 0 ;
34919 char * kwnames[] = {
34920 (char *) "self",(char *) "rect", NULL
34921 };
34922
34923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34925 if (!SWIG_IsOK(res1)) {
34926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34927 }
34928 arg1 = reinterpret_cast< wxWindow * >(argp1);
34929 {
34930 arg2 = &temp2;
34931 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34932 }
34933 {
34934 PyThreadState* __tstate = wxPyBeginAllowThreads();
34935 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34941 }
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34949 PyObject *resultobj = 0;
34950 wxWindow *arg1 = (wxWindow *) 0 ;
34951 SwigValueWrapper<wxVisualAttributes > result;
34952 void *argp1 = 0 ;
34953 int res1 = 0 ;
34954 PyObject *swig_obj[1] ;
34955
34956 if (!args) SWIG_fail;
34957 swig_obj[0] = args;
34958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34959 if (!SWIG_IsOK(res1)) {
34960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34961 }
34962 arg1 = reinterpret_cast< wxWindow * >(argp1);
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj = 0;
34978 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34979 SwigValueWrapper<wxVisualAttributes > result;
34980 int val1 ;
34981 int ecode1 = 0 ;
34982 PyObject * obj0 = 0 ;
34983 char * kwnames[] = {
34984 (char *) "variant", NULL
34985 };
34986
34987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34988 if (obj0) {
34989 ecode1 = SWIG_AsVal_int(obj0, &val1);
34990 if (!SWIG_IsOK(ecode1)) {
34991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34992 }
34993 arg1 = static_cast< wxWindowVariant >(val1);
34994 }
34995 {
34996 if (!wxPyCheckForApp()) SWIG_fail;
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 result = wxWindow::GetClassDefaultAttributes(arg1);
34999 wxPyEndAllowThreads(__tstate);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 }
35002 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35003 return resultobj;
35004 fail:
35005 return NULL;
35006 }
35007
35008
35009 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35010 PyObject *resultobj = 0;
35011 wxWindow *arg1 = (wxWindow *) 0 ;
35012 wxColour *arg2 = 0 ;
35013 bool result;
35014 void *argp1 = 0 ;
35015 int res1 = 0 ;
35016 wxColour temp2 ;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 char * kwnames[] = {
35020 (char *) "self",(char *) "colour", NULL
35021 };
35022
35023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",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_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35027 }
35028 arg1 = reinterpret_cast< wxWindow * >(argp1);
35029 {
35030 arg2 = &temp2;
35031 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35032 }
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 {
35040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35041 }
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 wxColour *arg2 = 0 ;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 wxColour temp2 ;
35055 PyObject * obj0 = 0 ;
35056 PyObject * obj1 = 0 ;
35057 char * kwnames[] = {
35058 (char *) "self",(char *) "colour", NULL
35059 };
35060
35061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35063 if (!SWIG_IsOK(res1)) {
35064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35065 }
35066 arg1 = reinterpret_cast< wxWindow * >(argp1);
35067 {
35068 arg2 = &temp2;
35069 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35070 }
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_Py_Void();
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 wxColour *arg2 = 0 ;
35088 bool result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 wxColour temp2 ;
35092 PyObject * obj0 = 0 ;
35093 PyObject * obj1 = 0 ;
35094 char * kwnames[] = {
35095 (char *) "self",(char *) "colour", NULL
35096 };
35097
35098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35100 if (!SWIG_IsOK(res1)) {
35101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35102 }
35103 arg1 = reinterpret_cast< wxWindow * >(argp1);
35104 {
35105 arg2 = &temp2;
35106 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35107 }
35108 {
35109 PyThreadState* __tstate = wxPyBeginAllowThreads();
35110 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35111 wxPyEndAllowThreads(__tstate);
35112 if (PyErr_Occurred()) SWIG_fail;
35113 }
35114 {
35115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35116 }
35117 return resultobj;
35118 fail:
35119 return NULL;
35120 }
35121
35122
35123 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35124 PyObject *resultobj = 0;
35125 wxWindow *arg1 = (wxWindow *) 0 ;
35126 wxColour *arg2 = 0 ;
35127 void *argp1 = 0 ;
35128 int res1 = 0 ;
35129 wxColour temp2 ;
35130 PyObject * obj0 = 0 ;
35131 PyObject * obj1 = 0 ;
35132 char * kwnames[] = {
35133 (char *) "self",(char *) "colour", NULL
35134 };
35135
35136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35138 if (!SWIG_IsOK(res1)) {
35139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35140 }
35141 arg1 = reinterpret_cast< wxWindow * >(argp1);
35142 {
35143 arg2 = &temp2;
35144 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35145 }
35146 {
35147 PyThreadState* __tstate = wxPyBeginAllowThreads();
35148 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35149 wxPyEndAllowThreads(__tstate);
35150 if (PyErr_Occurred()) SWIG_fail;
35151 }
35152 resultobj = SWIG_Py_Void();
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 wxColour result;
35163 void *argp1 = 0 ;
35164 int res1 = 0 ;
35165 PyObject *swig_obj[1] ;
35166
35167 if (!args) SWIG_fail;
35168 swig_obj[0] = args;
35169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35172 }
35173 arg1 = reinterpret_cast< wxWindow * >(argp1);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 wxColour result;
35191 void *argp1 = 0 ;
35192 int res1 = 0 ;
35193 PyObject *swig_obj[1] ;
35194
35195 if (!args) SWIG_fail;
35196 swig_obj[0] = args;
35197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35198 if (!SWIG_IsOK(res1)) {
35199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35200 }
35201 arg1 = reinterpret_cast< wxWindow * >(argp1);
35202 {
35203 PyThreadState* __tstate = wxPyBeginAllowThreads();
35204 result = ((wxWindow const *)arg1)->GetForegroundColour();
35205 wxPyEndAllowThreads(__tstate);
35206 if (PyErr_Occurred()) SWIG_fail;
35207 }
35208 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 bool result;
35219 void *argp1 = 0 ;
35220 int res1 = 0 ;
35221 PyObject *swig_obj[1] ;
35222
35223 if (!args) SWIG_fail;
35224 swig_obj[0] = args;
35225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35226 if (!SWIG_IsOK(res1)) {
35227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35228 }
35229 arg1 = reinterpret_cast< wxWindow * >(argp1);
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35233 wxPyEndAllowThreads(__tstate);
35234 if (PyErr_Occurred()) SWIG_fail;
35235 }
35236 {
35237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35238 }
35239 return resultobj;
35240 fail:
35241 return NULL;
35242 }
35243
35244
35245 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35246 PyObject *resultobj = 0;
35247 wxWindow *arg1 = (wxWindow *) 0 ;
35248 bool result;
35249 void *argp1 = 0 ;
35250 int res1 = 0 ;
35251 PyObject *swig_obj[1] ;
35252
35253 if (!args) SWIG_fail;
35254 swig_obj[0] = args;
35255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35258 }
35259 arg1 = reinterpret_cast< wxWindow * >(argp1);
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj = 0;
35277 wxWindow *arg1 = (wxWindow *) 0 ;
35278 wxBackgroundStyle arg2 ;
35279 bool result;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 int val2 ;
35283 int ecode2 = 0 ;
35284 PyObject * obj0 = 0 ;
35285 PyObject * obj1 = 0 ;
35286 char * kwnames[] = {
35287 (char *) "self",(char *) "style", NULL
35288 };
35289
35290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35292 if (!SWIG_IsOK(res1)) {
35293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35294 }
35295 arg1 = reinterpret_cast< wxWindow * >(argp1);
35296 ecode2 = SWIG_AsVal_int(obj1, &val2);
35297 if (!SWIG_IsOK(ecode2)) {
35298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35299 }
35300 arg2 = static_cast< wxBackgroundStyle >(val2);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 {
35308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35309 }
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35317 PyObject *resultobj = 0;
35318 wxWindow *arg1 = (wxWindow *) 0 ;
35319 wxBackgroundStyle result;
35320 void *argp1 = 0 ;
35321 int res1 = 0 ;
35322 PyObject *swig_obj[1] ;
35323
35324 if (!args) SWIG_fail;
35325 swig_obj[0] = args;
35326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35327 if (!SWIG_IsOK(res1)) {
35328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35329 }
35330 arg1 = reinterpret_cast< wxWindow * >(argp1);
35331 {
35332 PyThreadState* __tstate = wxPyBeginAllowThreads();
35333 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35334 wxPyEndAllowThreads(__tstate);
35335 if (PyErr_Occurred()) SWIG_fail;
35336 }
35337 resultobj = SWIG_From_int(static_cast< int >(result));
35338 return resultobj;
35339 fail:
35340 return NULL;
35341 }
35342
35343
35344 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35345 PyObject *resultobj = 0;
35346 wxWindow *arg1 = (wxWindow *) 0 ;
35347 bool result;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 PyObject *swig_obj[1] ;
35351
35352 if (!args) SWIG_fail;
35353 swig_obj[0] = args;
35354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 result = (bool)(arg1)->HasTransparentBackground();
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 {
35366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35367 }
35368 return resultobj;
35369 fail:
35370 return NULL;
35371 }
35372
35373
35374 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35375 PyObject *resultobj = 0;
35376 wxWindow *arg1 = (wxWindow *) 0 ;
35377 wxCursor *arg2 = 0 ;
35378 bool result;
35379 void *argp1 = 0 ;
35380 int res1 = 0 ;
35381 void *argp2 = 0 ;
35382 int res2 = 0 ;
35383 PyObject * obj0 = 0 ;
35384 PyObject * obj1 = 0 ;
35385 char * kwnames[] = {
35386 (char *) "self",(char *) "cursor", NULL
35387 };
35388
35389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35393 }
35394 arg1 = reinterpret_cast< wxWindow * >(argp1);
35395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35396 if (!SWIG_IsOK(res2)) {
35397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35398 }
35399 if (!argp2) {
35400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35401 }
35402 arg2 = reinterpret_cast< wxCursor * >(argp2);
35403 {
35404 PyThreadState* __tstate = wxPyBeginAllowThreads();
35405 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35406 wxPyEndAllowThreads(__tstate);
35407 if (PyErr_Occurred()) SWIG_fail;
35408 }
35409 {
35410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35411 }
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35419 PyObject *resultobj = 0;
35420 wxWindow *arg1 = (wxWindow *) 0 ;
35421 wxCursor result;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 PyObject *swig_obj[1] ;
35425
35426 if (!args) SWIG_fail;
35427 swig_obj[0] = args;
35428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = (arg1)->GetCursor();
35436 wxPyEndAllowThreads(__tstate);
35437 if (PyErr_Occurred()) SWIG_fail;
35438 }
35439 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = 0;
35448 wxWindow *arg1 = (wxWindow *) 0 ;
35449 wxFont *arg2 = 0 ;
35450 bool result;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 void *argp2 = 0 ;
35454 int res2 = 0 ;
35455 PyObject * obj0 = 0 ;
35456 PyObject * obj1 = 0 ;
35457 char * kwnames[] = {
35458 (char *) "self",(char *) "font", NULL
35459 };
35460
35461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35463 if (!SWIG_IsOK(res1)) {
35464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35465 }
35466 arg1 = reinterpret_cast< wxWindow * >(argp1);
35467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35468 if (!SWIG_IsOK(res2)) {
35469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35470 }
35471 if (!argp2) {
35472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35473 }
35474 arg2 = reinterpret_cast< wxFont * >(argp2);
35475 {
35476 PyThreadState* __tstate = wxPyBeginAllowThreads();
35477 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35478 wxPyEndAllowThreads(__tstate);
35479 if (PyErr_Occurred()) SWIG_fail;
35480 }
35481 {
35482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35483 }
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35491 PyObject *resultobj = 0;
35492 wxWindow *arg1 = (wxWindow *) 0 ;
35493 wxFont *arg2 = 0 ;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 void *argp2 = 0 ;
35497 int res2 = 0 ;
35498 PyObject * obj0 = 0 ;
35499 PyObject * obj1 = 0 ;
35500 char * kwnames[] = {
35501 (char *) "self",(char *) "font", NULL
35502 };
35503
35504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35506 if (!SWIG_IsOK(res1)) {
35507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35508 }
35509 arg1 = reinterpret_cast< wxWindow * >(argp1);
35510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35511 if (!SWIG_IsOK(res2)) {
35512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35513 }
35514 if (!argp2) {
35515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35516 }
35517 arg2 = reinterpret_cast< wxFont * >(argp2);
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 (arg1)->SetOwnFont((wxFont const &)*arg2);
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 resultobj = SWIG_Py_Void();
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35532 PyObject *resultobj = 0;
35533 wxWindow *arg1 = (wxWindow *) 0 ;
35534 wxFont result;
35535 void *argp1 = 0 ;
35536 int res1 = 0 ;
35537 PyObject *swig_obj[1] ;
35538
35539 if (!args) SWIG_fail;
35540 swig_obj[0] = args;
35541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35544 }
35545 arg1 = reinterpret_cast< wxWindow * >(argp1);
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 result = (arg1)->GetFont();
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35553 return resultobj;
35554 fail:
35555 return NULL;
35556 }
35557
35558
35559 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35560 PyObject *resultobj = 0;
35561 wxWindow *arg1 = (wxWindow *) 0 ;
35562 wxCaret *arg2 = (wxCaret *) 0 ;
35563 void *argp1 = 0 ;
35564 int res1 = 0 ;
35565 int res2 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "caret", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35579 if (!SWIG_IsOK(res2)) {
35580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35581 }
35582 {
35583 PyThreadState* __tstate = wxPyBeginAllowThreads();
35584 (arg1)->SetCaret(arg2);
35585 wxPyEndAllowThreads(__tstate);
35586 if (PyErr_Occurred()) SWIG_fail;
35587 }
35588 resultobj = SWIG_Py_Void();
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35596 PyObject *resultobj = 0;
35597 wxWindow *arg1 = (wxWindow *) 0 ;
35598 wxCaret *result = 0 ;
35599 void *argp1 = 0 ;
35600 int res1 = 0 ;
35601 PyObject *swig_obj[1] ;
35602
35603 if (!args) SWIG_fail;
35604 swig_obj[0] = args;
35605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35606 if (!SWIG_IsOK(res1)) {
35607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35608 }
35609 arg1 = reinterpret_cast< wxWindow * >(argp1);
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35617 return resultobj;
35618 fail:
35619 return NULL;
35620 }
35621
35622
35623 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35624 PyObject *resultobj = 0;
35625 wxWindow *arg1 = (wxWindow *) 0 ;
35626 int result;
35627 void *argp1 = 0 ;
35628 int res1 = 0 ;
35629 PyObject *swig_obj[1] ;
35630
35631 if (!args) SWIG_fail;
35632 swig_obj[0] = args;
35633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35636 }
35637 arg1 = reinterpret_cast< wxWindow * >(argp1);
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 resultobj = SWIG_From_int(static_cast< int >(result));
35645 return resultobj;
35646 fail:
35647 return NULL;
35648 }
35649
35650
35651 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35652 PyObject *resultobj = 0;
35653 wxWindow *arg1 = (wxWindow *) 0 ;
35654 int result;
35655 void *argp1 = 0 ;
35656 int res1 = 0 ;
35657 PyObject *swig_obj[1] ;
35658
35659 if (!args) SWIG_fail;
35660 swig_obj[0] = args;
35661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35662 if (!SWIG_IsOK(res1)) {
35663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35664 }
35665 arg1 = reinterpret_cast< wxWindow * >(argp1);
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 resultobj = SWIG_From_int(static_cast< int >(result));
35673 return resultobj;
35674 fail:
35675 return NULL;
35676 }
35677
35678
35679 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35680 PyObject *resultobj = 0;
35681 wxWindow *arg1 = (wxWindow *) 0 ;
35682 wxString *arg2 = 0 ;
35683 int *arg3 = (int *) 0 ;
35684 int *arg4 = (int *) 0 ;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 bool temp2 = false ;
35688 int temp3 ;
35689 int res3 = SWIG_TMPOBJ ;
35690 int temp4 ;
35691 int res4 = SWIG_TMPOBJ ;
35692 PyObject * obj0 = 0 ;
35693 PyObject * obj1 = 0 ;
35694 char * kwnames[] = {
35695 (char *) "self",(char *) "string", NULL
35696 };
35697
35698 arg3 = &temp3;
35699 arg4 = &temp4;
35700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35702 if (!SWIG_IsOK(res1)) {
35703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35704 }
35705 arg1 = reinterpret_cast< wxWindow * >(argp1);
35706 {
35707 arg2 = wxString_in_helper(obj1);
35708 if (arg2 == NULL) SWIG_fail;
35709 temp2 = true;
35710 }
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 resultobj = SWIG_Py_Void();
35718 if (SWIG_IsTmpObj(res3)) {
35719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35720 } else {
35721 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35723 }
35724 if (SWIG_IsTmpObj(res4)) {
35725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35726 } else {
35727 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35729 }
35730 {
35731 if (temp2)
35732 delete arg2;
35733 }
35734 return resultobj;
35735 fail:
35736 {
35737 if (temp2)
35738 delete arg2;
35739 }
35740 return NULL;
35741 }
35742
35743
35744 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35745 PyObject *resultobj = 0;
35746 wxWindow *arg1 = (wxWindow *) 0 ;
35747 wxString *arg2 = 0 ;
35748 int *arg3 = (int *) 0 ;
35749 int *arg4 = (int *) 0 ;
35750 int *arg5 = (int *) 0 ;
35751 int *arg6 = (int *) 0 ;
35752 wxFont *arg7 = (wxFont *) NULL ;
35753 void *argp1 = 0 ;
35754 int res1 = 0 ;
35755 bool temp2 = false ;
35756 int temp3 ;
35757 int res3 = SWIG_TMPOBJ ;
35758 int temp4 ;
35759 int res4 = SWIG_TMPOBJ ;
35760 int temp5 ;
35761 int res5 = SWIG_TMPOBJ ;
35762 int temp6 ;
35763 int res6 = SWIG_TMPOBJ ;
35764 void *argp7 = 0 ;
35765 int res7 = 0 ;
35766 PyObject * obj0 = 0 ;
35767 PyObject * obj1 = 0 ;
35768 PyObject * obj2 = 0 ;
35769 char * kwnames[] = {
35770 (char *) "self",(char *) "string",(char *) "font", NULL
35771 };
35772
35773 arg3 = &temp3;
35774 arg4 = &temp4;
35775 arg5 = &temp5;
35776 arg6 = &temp6;
35777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 arg2 = wxString_in_helper(obj1);
35785 if (arg2 == NULL) SWIG_fail;
35786 temp2 = true;
35787 }
35788 if (obj2) {
35789 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35790 if (!SWIG_IsOK(res7)) {
35791 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35792 }
35793 arg7 = reinterpret_cast< wxFont * >(argp7);
35794 }
35795 {
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35798 wxPyEndAllowThreads(__tstate);
35799 if (PyErr_Occurred()) SWIG_fail;
35800 }
35801 resultobj = SWIG_Py_Void();
35802 if (SWIG_IsTmpObj(res3)) {
35803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35804 } else {
35805 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35807 }
35808 if (SWIG_IsTmpObj(res4)) {
35809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35810 } else {
35811 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35813 }
35814 if (SWIG_IsTmpObj(res5)) {
35815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35816 } else {
35817 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35819 }
35820 if (SWIG_IsTmpObj(res6)) {
35821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35822 } else {
35823 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35825 }
35826 {
35827 if (temp2)
35828 delete arg2;
35829 }
35830 return resultobj;
35831 fail:
35832 {
35833 if (temp2)
35834 delete arg2;
35835 }
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35841 PyObject *resultobj = 0;
35842 wxWindow *arg1 = (wxWindow *) 0 ;
35843 int *arg2 = (int *) 0 ;
35844 int *arg3 = (int *) 0 ;
35845 void *argp1 = 0 ;
35846 int res1 = 0 ;
35847 int temp2 ;
35848 int res2 = 0 ;
35849 int temp3 ;
35850 int res3 = 0 ;
35851 PyObject * obj0 = 0 ;
35852 PyObject * obj1 = 0 ;
35853 PyObject * obj2 = 0 ;
35854 char * kwnames[] = {
35855 (char *) "self",(char *) "x",(char *) "y", NULL
35856 };
35857
35858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35860 if (!SWIG_IsOK(res1)) {
35861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35862 }
35863 arg1 = reinterpret_cast< wxWindow * >(argp1);
35864 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35865 int val;
35866 int ecode = SWIG_AsVal_int(obj1, &val);
35867 if (!SWIG_IsOK(ecode)) {
35868 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35869 }
35870 temp2 = static_cast< int >(val);
35871 arg2 = &temp2;
35872 res2 = SWIG_AddTmpMask(ecode);
35873 }
35874 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35875 int val;
35876 int ecode = SWIG_AsVal_int(obj2, &val);
35877 if (!SWIG_IsOK(ecode)) {
35878 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35879 }
35880 temp3 = static_cast< int >(val);
35881 arg3 = &temp3;
35882 res3 = SWIG_AddTmpMask(ecode);
35883 }
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 resultobj = SWIG_Py_Void();
35891 if (SWIG_IsTmpObj(res2)) {
35892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35893 } else {
35894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35896 }
35897 if (SWIG_IsTmpObj(res3)) {
35898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35899 } else {
35900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35902 }
35903 return resultobj;
35904 fail:
35905 return NULL;
35906 }
35907
35908
35909 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35910 PyObject *resultobj = 0;
35911 wxWindow *arg1 = (wxWindow *) 0 ;
35912 int *arg2 = (int *) 0 ;
35913 int *arg3 = (int *) 0 ;
35914 void *argp1 = 0 ;
35915 int res1 = 0 ;
35916 int temp2 ;
35917 int res2 = 0 ;
35918 int temp3 ;
35919 int res3 = 0 ;
35920 PyObject * obj0 = 0 ;
35921 PyObject * obj1 = 0 ;
35922 PyObject * obj2 = 0 ;
35923 char * kwnames[] = {
35924 (char *) "self",(char *) "x",(char *) "y", NULL
35925 };
35926
35927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35929 if (!SWIG_IsOK(res1)) {
35930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35931 }
35932 arg1 = reinterpret_cast< wxWindow * >(argp1);
35933 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35934 int val;
35935 int ecode = SWIG_AsVal_int(obj1, &val);
35936 if (!SWIG_IsOK(ecode)) {
35937 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35938 }
35939 temp2 = static_cast< int >(val);
35940 arg2 = &temp2;
35941 res2 = SWIG_AddTmpMask(ecode);
35942 }
35943 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35944 int val;
35945 int ecode = SWIG_AsVal_int(obj2, &val);
35946 if (!SWIG_IsOK(ecode)) {
35947 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35948 }
35949 temp3 = static_cast< int >(val);
35950 arg3 = &temp3;
35951 res3 = SWIG_AddTmpMask(ecode);
35952 }
35953 {
35954 PyThreadState* __tstate = wxPyBeginAllowThreads();
35955 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35956 wxPyEndAllowThreads(__tstate);
35957 if (PyErr_Occurred()) SWIG_fail;
35958 }
35959 resultobj = SWIG_Py_Void();
35960 if (SWIG_IsTmpObj(res2)) {
35961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35962 } else {
35963 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35965 }
35966 if (SWIG_IsTmpObj(res3)) {
35967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35968 } else {
35969 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35971 }
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 wxPoint *arg2 = 0 ;
35982 wxPoint result;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 wxPoint temp2 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "pt", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35996 }
35997 arg1 = reinterpret_cast< wxWindow * >(argp1);
35998 {
35999 arg2 = &temp2;
36000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36001 }
36002 {
36003 PyThreadState* __tstate = wxPyBeginAllowThreads();
36004 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36009 return resultobj;
36010 fail:
36011 return NULL;
36012 }
36013
36014
36015 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36016 PyObject *resultobj = 0;
36017 wxWindow *arg1 = (wxWindow *) 0 ;
36018 wxPoint *arg2 = 0 ;
36019 wxPoint result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 wxPoint temp2 ;
36023 PyObject * obj0 = 0 ;
36024 PyObject * obj1 = 0 ;
36025 char * kwnames[] = {
36026 (char *) "self",(char *) "pt", NULL
36027 };
36028
36029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxWindow * >(argp1);
36035 {
36036 arg2 = &temp2;
36037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36038 }
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36053 PyObject *resultobj = 0;
36054 wxWindow *arg1 = (wxWindow *) 0 ;
36055 int arg2 ;
36056 int arg3 ;
36057 wxHitTest result;
36058 void *argp1 = 0 ;
36059 int res1 = 0 ;
36060 int val2 ;
36061 int ecode2 = 0 ;
36062 int val3 ;
36063 int ecode3 = 0 ;
36064 PyObject * obj0 = 0 ;
36065 PyObject * obj1 = 0 ;
36066 PyObject * obj2 = 0 ;
36067 char * kwnames[] = {
36068 (char *) "self",(char *) "x",(char *) "y", NULL
36069 };
36070
36071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36075 }
36076 arg1 = reinterpret_cast< wxWindow * >(argp1);
36077 ecode2 = SWIG_AsVal_int(obj1, &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36080 }
36081 arg2 = static_cast< int >(val2);
36082 ecode3 = SWIG_AsVal_int(obj2, &val3);
36083 if (!SWIG_IsOK(ecode3)) {
36084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36085 }
36086 arg3 = static_cast< int >(val3);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_From_int(static_cast< int >(result));
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 wxPoint *arg2 = 0 ;
36104 wxHitTest result;
36105 void *argp1 = 0 ;
36106 int res1 = 0 ;
36107 wxPoint temp2 ;
36108 PyObject * obj0 = 0 ;
36109 PyObject * obj1 = 0 ;
36110 char * kwnames[] = {
36111 (char *) "self",(char *) "pt", NULL
36112 };
36113
36114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36116 if (!SWIG_IsOK(res1)) {
36117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36118 }
36119 arg1 = reinterpret_cast< wxWindow * >(argp1);
36120 {
36121 arg2 = &temp2;
36122 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36123 }
36124 {
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36127 wxPyEndAllowThreads(__tstate);
36128 if (PyErr_Occurred()) SWIG_fail;
36129 }
36130 resultobj = SWIG_From_int(static_cast< int >(result));
36131 return resultobj;
36132 fail:
36133 return NULL;
36134 }
36135
36136
36137 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36138 PyObject *resultobj = 0;
36139 wxWindow *arg1 = (wxWindow *) 0 ;
36140 long arg2 ;
36141 wxBorder result;
36142 void *argp1 = 0 ;
36143 int res1 = 0 ;
36144 long val2 ;
36145 int ecode2 = 0 ;
36146
36147 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36149 if (!SWIG_IsOK(res1)) {
36150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36151 }
36152 arg1 = reinterpret_cast< wxWindow * >(argp1);
36153 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36154 if (!SWIG_IsOK(ecode2)) {
36155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36156 }
36157 arg2 = static_cast< long >(val2);
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 resultobj = SWIG_From_int(static_cast< int >(result));
36165 return resultobj;
36166 fail:
36167 return NULL;
36168 }
36169
36170
36171 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36172 PyObject *resultobj = 0;
36173 wxWindow *arg1 = (wxWindow *) 0 ;
36174 wxBorder result;
36175 void *argp1 = 0 ;
36176 int res1 = 0 ;
36177
36178 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 {
36185 PyThreadState* __tstate = wxPyBeginAllowThreads();
36186 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 resultobj = SWIG_From_int(static_cast< int >(result));
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36198 int argc;
36199 PyObject *argv[3];
36200
36201 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36202 --argc;
36203 if (argc == 1) {
36204 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36205 }
36206 if (argc == 2) {
36207 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36208 }
36209
36210 fail:
36211 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36212 return NULL;
36213 }
36214
36215
36216 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36217 PyObject *resultobj = 0;
36218 wxWindow *arg1 = (wxWindow *) 0 ;
36219 long arg2 = (long) wxUPDATE_UI_NONE ;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 long val2 ;
36223 int ecode2 = 0 ;
36224 PyObject * obj0 = 0 ;
36225 PyObject * obj1 = 0 ;
36226 char * kwnames[] = {
36227 (char *) "self",(char *) "flags", NULL
36228 };
36229
36230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36232 if (!SWIG_IsOK(res1)) {
36233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36234 }
36235 arg1 = reinterpret_cast< wxWindow * >(argp1);
36236 if (obj1) {
36237 ecode2 = SWIG_AsVal_long(obj1, &val2);
36238 if (!SWIG_IsOK(ecode2)) {
36239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36240 }
36241 arg2 = static_cast< long >(val2);
36242 }
36243 {
36244 PyThreadState* __tstate = wxPyBeginAllowThreads();
36245 (arg1)->UpdateWindowUI(arg2);
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 resultobj = SWIG_Py_Void();
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj = 0;
36258 wxWindow *arg1 = (wxWindow *) 0 ;
36259 wxMenu *arg2 = (wxMenu *) 0 ;
36260 int arg3 = (int) -1 ;
36261 int arg4 = (int) -1 ;
36262 bool result;
36263 void *argp1 = 0 ;
36264 int res1 = 0 ;
36265 void *argp2 = 0 ;
36266 int res2 = 0 ;
36267 int val3 ;
36268 int ecode3 = 0 ;
36269 int val4 ;
36270 int ecode4 = 0 ;
36271 PyObject * obj0 = 0 ;
36272 PyObject * obj1 = 0 ;
36273 PyObject * obj2 = 0 ;
36274 PyObject * obj3 = 0 ;
36275 char * kwnames[] = {
36276 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36277 };
36278
36279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36281 if (!SWIG_IsOK(res1)) {
36282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36283 }
36284 arg1 = reinterpret_cast< wxWindow * >(argp1);
36285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36286 if (!SWIG_IsOK(res2)) {
36287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36288 }
36289 arg2 = reinterpret_cast< wxMenu * >(argp2);
36290 if (obj2) {
36291 ecode3 = SWIG_AsVal_int(obj2, &val3);
36292 if (!SWIG_IsOK(ecode3)) {
36293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36294 }
36295 arg3 = static_cast< int >(val3);
36296 }
36297 if (obj3) {
36298 ecode4 = SWIG_AsVal_int(obj3, &val4);
36299 if (!SWIG_IsOK(ecode4)) {
36300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36301 }
36302 arg4 = static_cast< int >(val4);
36303 }
36304 {
36305 PyThreadState* __tstate = wxPyBeginAllowThreads();
36306 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36307 wxPyEndAllowThreads(__tstate);
36308 if (PyErr_Occurred()) SWIG_fail;
36309 }
36310 {
36311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36312 }
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj = 0;
36321 wxWindow *arg1 = (wxWindow *) 0 ;
36322 wxMenu *arg2 = (wxMenu *) 0 ;
36323 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36324 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36325 bool result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 void *argp2 = 0 ;
36329 int res2 = 0 ;
36330 wxPoint temp3 ;
36331 PyObject * obj0 = 0 ;
36332 PyObject * obj1 = 0 ;
36333 PyObject * obj2 = 0 ;
36334 char * kwnames[] = {
36335 (char *) "self",(char *) "menu",(char *) "pos", NULL
36336 };
36337
36338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36340 if (!SWIG_IsOK(res1)) {
36341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36342 }
36343 arg1 = reinterpret_cast< wxWindow * >(argp1);
36344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36345 if (!SWIG_IsOK(res2)) {
36346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36347 }
36348 arg2 = reinterpret_cast< wxMenu * >(argp2);
36349 if (obj2) {
36350 {
36351 arg3 = &temp3;
36352 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36353 }
36354 }
36355 {
36356 PyThreadState* __tstate = wxPyBeginAllowThreads();
36357 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36358 wxPyEndAllowThreads(__tstate);
36359 if (PyErr_Occurred()) SWIG_fail;
36360 }
36361 {
36362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36363 }
36364 return resultobj;
36365 fail:
36366 return NULL;
36367 }
36368
36369
36370 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36371 PyObject *resultobj = 0;
36372 wxWindow *arg1 = (wxWindow *) 0 ;
36373 bool result;
36374 void *argp1 = 0 ;
36375 int res1 = 0 ;
36376 PyObject *swig_obj[1] ;
36377
36378 if (!args) SWIG_fail;
36379 swig_obj[0] = args;
36380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36381 if (!SWIG_IsOK(res1)) {
36382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36383 }
36384 arg1 = reinterpret_cast< wxWindow * >(argp1);
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36388 wxPyEndAllowThreads(__tstate);
36389 if (PyErr_Occurred()) SWIG_fail;
36390 }
36391 {
36392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36393 }
36394 return resultobj;
36395 fail:
36396 return NULL;
36397 }
36398
36399
36400 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36401 PyObject *resultobj = 0;
36402 wxWindow *arg1 = (wxWindow *) 0 ;
36403 long result;
36404 void *argp1 = 0 ;
36405 int res1 = 0 ;
36406 PyObject *swig_obj[1] ;
36407
36408 if (!args) SWIG_fail;
36409 swig_obj[0] = args;
36410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36411 if (!SWIG_IsOK(res1)) {
36412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36413 }
36414 arg1 = reinterpret_cast< wxWindow * >(argp1);
36415 {
36416 PyThreadState* __tstate = wxPyBeginAllowThreads();
36417 result = (long)wxWindow_GetHandle(arg1);
36418 wxPyEndAllowThreads(__tstate);
36419 if (PyErr_Occurred()) SWIG_fail;
36420 }
36421 resultobj = SWIG_From_long(static_cast< long >(result));
36422 return resultobj;
36423 fail:
36424 return NULL;
36425 }
36426
36427
36428 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36429 PyObject *resultobj = 0;
36430 wxWindow *arg1 = (wxWindow *) 0 ;
36431 long arg2 ;
36432 void *argp1 = 0 ;
36433 int res1 = 0 ;
36434 long val2 ;
36435 int ecode2 = 0 ;
36436 PyObject * obj0 = 0 ;
36437 PyObject * obj1 = 0 ;
36438 char * kwnames[] = {
36439 (char *) "self",(char *) "handle", NULL
36440 };
36441
36442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36444 if (!SWIG_IsOK(res1)) {
36445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36446 }
36447 arg1 = reinterpret_cast< wxWindow * >(argp1);
36448 ecode2 = SWIG_AsVal_long(obj1, &val2);
36449 if (!SWIG_IsOK(ecode2)) {
36450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36451 }
36452 arg2 = static_cast< long >(val2);
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 wxWindow_AssociateHandle(arg1,arg2);
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 resultobj = SWIG_Py_Void();
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 void *argp1 = 0 ;
36470 int res1 = 0 ;
36471 PyObject *swig_obj[1] ;
36472
36473 if (!args) SWIG_fail;
36474 swig_obj[0] = args;
36475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36476 if (!SWIG_IsOK(res1)) {
36477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36478 }
36479 arg1 = reinterpret_cast< wxWindow * >(argp1);
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 (arg1)->DissociateHandle();
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 resultobj = SWIG_Py_Void();
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36494 PyObject *resultobj = 0;
36495 wxWindow *arg1 = (wxWindow *) 0 ;
36496 int arg2 ;
36497 bool result;
36498 void *argp1 = 0 ;
36499 int res1 = 0 ;
36500 int val2 ;
36501 int ecode2 = 0 ;
36502 PyObject * obj0 = 0 ;
36503 PyObject * obj1 = 0 ;
36504 char * kwnames[] = {
36505 (char *) "self",(char *) "orient", NULL
36506 };
36507
36508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36510 if (!SWIG_IsOK(res1)) {
36511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36512 }
36513 arg1 = reinterpret_cast< wxWindow * >(argp1);
36514 ecode2 = SWIG_AsVal_int(obj1, &val2);
36515 if (!SWIG_IsOK(ecode2)) {
36516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36517 }
36518 arg2 = static_cast< int >(val2);
36519 {
36520 PyThreadState* __tstate = wxPyBeginAllowThreads();
36521 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 {
36526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36527 }
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj = 0;
36536 wxWindow *arg1 = (wxWindow *) 0 ;
36537 int arg2 ;
36538 int arg3 ;
36539 int arg4 ;
36540 int arg5 ;
36541 bool arg6 = (bool) true ;
36542 void *argp1 = 0 ;
36543 int res1 = 0 ;
36544 int val2 ;
36545 int ecode2 = 0 ;
36546 int val3 ;
36547 int ecode3 = 0 ;
36548 int val4 ;
36549 int ecode4 = 0 ;
36550 int val5 ;
36551 int ecode5 = 0 ;
36552 bool val6 ;
36553 int ecode6 = 0 ;
36554 PyObject * obj0 = 0 ;
36555 PyObject * obj1 = 0 ;
36556 PyObject * obj2 = 0 ;
36557 PyObject * obj3 = 0 ;
36558 PyObject * obj4 = 0 ;
36559 PyObject * obj5 = 0 ;
36560 char * kwnames[] = {
36561 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36562 };
36563
36564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36566 if (!SWIG_IsOK(res1)) {
36567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36568 }
36569 arg1 = reinterpret_cast< wxWindow * >(argp1);
36570 ecode2 = SWIG_AsVal_int(obj1, &val2);
36571 if (!SWIG_IsOK(ecode2)) {
36572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36573 }
36574 arg2 = static_cast< int >(val2);
36575 ecode3 = SWIG_AsVal_int(obj2, &val3);
36576 if (!SWIG_IsOK(ecode3)) {
36577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36578 }
36579 arg3 = static_cast< int >(val3);
36580 ecode4 = SWIG_AsVal_int(obj3, &val4);
36581 if (!SWIG_IsOK(ecode4)) {
36582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36583 }
36584 arg4 = static_cast< int >(val4);
36585 ecode5 = SWIG_AsVal_int(obj4, &val5);
36586 if (!SWIG_IsOK(ecode5)) {
36587 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36588 }
36589 arg5 = static_cast< int >(val5);
36590 if (obj5) {
36591 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36592 if (!SWIG_IsOK(ecode6)) {
36593 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36594 }
36595 arg6 = static_cast< bool >(val6);
36596 }
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 resultobj = SWIG_Py_Void();
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 int arg2 ;
36614 int arg3 ;
36615 bool arg4 = (bool) true ;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 int val2 ;
36619 int ecode2 = 0 ;
36620 int val3 ;
36621 int ecode3 = 0 ;
36622 bool val4 ;
36623 int ecode4 = 0 ;
36624 PyObject * obj0 = 0 ;
36625 PyObject * obj1 = 0 ;
36626 PyObject * obj2 = 0 ;
36627 PyObject * obj3 = 0 ;
36628 char * kwnames[] = {
36629 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36630 };
36631
36632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36636 }
36637 arg1 = reinterpret_cast< wxWindow * >(argp1);
36638 ecode2 = SWIG_AsVal_int(obj1, &val2);
36639 if (!SWIG_IsOK(ecode2)) {
36640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36641 }
36642 arg2 = static_cast< int >(val2);
36643 ecode3 = SWIG_AsVal_int(obj2, &val3);
36644 if (!SWIG_IsOK(ecode3)) {
36645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36646 }
36647 arg3 = static_cast< int >(val3);
36648 if (obj3) {
36649 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36650 if (!SWIG_IsOK(ecode4)) {
36651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36652 }
36653 arg4 = static_cast< bool >(val4);
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 (arg1)->SetScrollPos(arg2,arg3,arg4);
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 resultobj = SWIG_Py_Void();
36662 return resultobj;
36663 fail:
36664 return NULL;
36665 }
36666
36667
36668 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36669 PyObject *resultobj = 0;
36670 wxWindow *arg1 = (wxWindow *) 0 ;
36671 int arg2 ;
36672 int result;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 int val2 ;
36676 int ecode2 = 0 ;
36677 PyObject * obj0 = 0 ;
36678 PyObject * obj1 = 0 ;
36679 char * kwnames[] = {
36680 (char *) "self",(char *) "orientation", NULL
36681 };
36682
36683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36687 }
36688 arg1 = reinterpret_cast< wxWindow * >(argp1);
36689 ecode2 = SWIG_AsVal_int(obj1, &val2);
36690 if (!SWIG_IsOK(ecode2)) {
36691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36692 }
36693 arg2 = static_cast< int >(val2);
36694 {
36695 PyThreadState* __tstate = wxPyBeginAllowThreads();
36696 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36697 wxPyEndAllowThreads(__tstate);
36698 if (PyErr_Occurred()) SWIG_fail;
36699 }
36700 resultobj = SWIG_From_int(static_cast< int >(result));
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36708 PyObject *resultobj = 0;
36709 wxWindow *arg1 = (wxWindow *) 0 ;
36710 int arg2 ;
36711 int result;
36712 void *argp1 = 0 ;
36713 int res1 = 0 ;
36714 int val2 ;
36715 int ecode2 = 0 ;
36716 PyObject * obj0 = 0 ;
36717 PyObject * obj1 = 0 ;
36718 char * kwnames[] = {
36719 (char *) "self",(char *) "orientation", NULL
36720 };
36721
36722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36724 if (!SWIG_IsOK(res1)) {
36725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36726 }
36727 arg1 = reinterpret_cast< wxWindow * >(argp1);
36728 ecode2 = SWIG_AsVal_int(obj1, &val2);
36729 if (!SWIG_IsOK(ecode2)) {
36730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36731 }
36732 arg2 = static_cast< int >(val2);
36733 {
36734 PyThreadState* __tstate = wxPyBeginAllowThreads();
36735 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36736 wxPyEndAllowThreads(__tstate);
36737 if (PyErr_Occurred()) SWIG_fail;
36738 }
36739 resultobj = SWIG_From_int(static_cast< int >(result));
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36747 PyObject *resultobj = 0;
36748 wxWindow *arg1 = (wxWindow *) 0 ;
36749 int arg2 ;
36750 int result;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 int val2 ;
36754 int ecode2 = 0 ;
36755 PyObject * obj0 = 0 ;
36756 PyObject * obj1 = 0 ;
36757 char * kwnames[] = {
36758 (char *) "self",(char *) "orientation", NULL
36759 };
36760
36761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36763 if (!SWIG_IsOK(res1)) {
36764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36765 }
36766 arg1 = reinterpret_cast< wxWindow * >(argp1);
36767 ecode2 = SWIG_AsVal_int(obj1, &val2);
36768 if (!SWIG_IsOK(ecode2)) {
36769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36770 }
36771 arg2 = static_cast< int >(val2);
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36775 wxPyEndAllowThreads(__tstate);
36776 if (PyErr_Occurred()) SWIG_fail;
36777 }
36778 resultobj = SWIG_From_int(static_cast< int >(result));
36779 return resultobj;
36780 fail:
36781 return NULL;
36782 }
36783
36784
36785 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36786 PyObject *resultobj = 0;
36787 wxWindow *arg1 = (wxWindow *) 0 ;
36788 int arg2 ;
36789 int arg3 ;
36790 wxRect *arg4 = (wxRect *) NULL ;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 int val2 ;
36794 int ecode2 = 0 ;
36795 int val3 ;
36796 int ecode3 = 0 ;
36797 void *argp4 = 0 ;
36798 int res4 = 0 ;
36799 PyObject * obj0 = 0 ;
36800 PyObject * obj1 = 0 ;
36801 PyObject * obj2 = 0 ;
36802 PyObject * obj3 = 0 ;
36803 char * kwnames[] = {
36804 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36805 };
36806
36807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36809 if (!SWIG_IsOK(res1)) {
36810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36811 }
36812 arg1 = reinterpret_cast< wxWindow * >(argp1);
36813 ecode2 = SWIG_AsVal_int(obj1, &val2);
36814 if (!SWIG_IsOK(ecode2)) {
36815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36816 }
36817 arg2 = static_cast< int >(val2);
36818 ecode3 = SWIG_AsVal_int(obj2, &val3);
36819 if (!SWIG_IsOK(ecode3)) {
36820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36821 }
36822 arg3 = static_cast< int >(val3);
36823 if (obj3) {
36824 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36825 if (!SWIG_IsOK(res4)) {
36826 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36827 }
36828 arg4 = reinterpret_cast< wxRect * >(argp4);
36829 }
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 resultobj = SWIG_Py_Void();
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36844 PyObject *resultobj = 0;
36845 wxWindow *arg1 = (wxWindow *) 0 ;
36846 int arg2 ;
36847 bool result;
36848 void *argp1 = 0 ;
36849 int res1 = 0 ;
36850 int val2 ;
36851 int ecode2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "lines", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 ecode2 = SWIG_AsVal_int(obj1, &val2);
36865 if (!SWIG_IsOK(ecode2)) {
36866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36867 }
36868 arg2 = static_cast< int >(val2);
36869 {
36870 PyThreadState* __tstate = wxPyBeginAllowThreads();
36871 result = (bool)(arg1)->ScrollLines(arg2);
36872 wxPyEndAllowThreads(__tstate);
36873 if (PyErr_Occurred()) SWIG_fail;
36874 }
36875 {
36876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36877 }
36878 return resultobj;
36879 fail:
36880 return NULL;
36881 }
36882
36883
36884 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36885 PyObject *resultobj = 0;
36886 wxWindow *arg1 = (wxWindow *) 0 ;
36887 int arg2 ;
36888 bool result;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 int val2 ;
36892 int ecode2 = 0 ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "pages", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 ecode2 = SWIG_AsVal_int(obj1, &val2);
36906 if (!SWIG_IsOK(ecode2)) {
36907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36908 }
36909 arg2 = static_cast< int >(val2);
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 result = (bool)(arg1)->ScrollPages(arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 {
36917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36918 }
36919 return resultobj;
36920 fail:
36921 return NULL;
36922 }
36923
36924
36925 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36926 PyObject *resultobj = 0;
36927 wxWindow *arg1 = (wxWindow *) 0 ;
36928 bool result;
36929 void *argp1 = 0 ;
36930 int res1 = 0 ;
36931 PyObject *swig_obj[1] ;
36932
36933 if (!args) SWIG_fail;
36934 swig_obj[0] = args;
36935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36938 }
36939 arg1 = reinterpret_cast< wxWindow * >(argp1);
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = (bool)(arg1)->LineUp();
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 {
36947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36948 }
36949 return resultobj;
36950 fail:
36951 return NULL;
36952 }
36953
36954
36955 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36956 PyObject *resultobj = 0;
36957 wxWindow *arg1 = (wxWindow *) 0 ;
36958 bool result;
36959 void *argp1 = 0 ;
36960 int res1 = 0 ;
36961 PyObject *swig_obj[1] ;
36962
36963 if (!args) SWIG_fail;
36964 swig_obj[0] = args;
36965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36966 if (!SWIG_IsOK(res1)) {
36967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36968 }
36969 arg1 = reinterpret_cast< wxWindow * >(argp1);
36970 {
36971 PyThreadState* __tstate = wxPyBeginAllowThreads();
36972 result = (bool)(arg1)->LineDown();
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 {
36977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36978 }
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36986 PyObject *resultobj = 0;
36987 wxWindow *arg1 = (wxWindow *) 0 ;
36988 bool result;
36989 void *argp1 = 0 ;
36990 int res1 = 0 ;
36991 PyObject *swig_obj[1] ;
36992
36993 if (!args) SWIG_fail;
36994 swig_obj[0] = args;
36995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36996 if (!SWIG_IsOK(res1)) {
36997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36998 }
36999 arg1 = reinterpret_cast< wxWindow * >(argp1);
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = (bool)(arg1)->PageUp();
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 {
37007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37008 }
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37016 PyObject *resultobj = 0;
37017 wxWindow *arg1 = (wxWindow *) 0 ;
37018 bool result;
37019 void *argp1 = 0 ;
37020 int res1 = 0 ;
37021 PyObject *swig_obj[1] ;
37022
37023 if (!args) SWIG_fail;
37024 swig_obj[0] = args;
37025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37026 if (!SWIG_IsOK(res1)) {
37027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37028 }
37029 arg1 = reinterpret_cast< wxWindow * >(argp1);
37030 {
37031 PyThreadState* __tstate = wxPyBeginAllowThreads();
37032 result = (bool)(arg1)->PageDown();
37033 wxPyEndAllowThreads(__tstate);
37034 if (PyErr_Occurred()) SWIG_fail;
37035 }
37036 {
37037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37038 }
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj = 0;
37047 wxWindow *arg1 = (wxWindow *) 0 ;
37048 wxString *arg2 = 0 ;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051 bool temp2 = false ;
37052 PyObject * obj0 = 0 ;
37053 PyObject * obj1 = 0 ;
37054 char * kwnames[] = {
37055 (char *) "self",(char *) "text", NULL
37056 };
37057
37058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 arg2 = wxString_in_helper(obj1);
37066 if (arg2 == NULL) SWIG_fail;
37067 temp2 = true;
37068 }
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 (arg1)->SetHelpText((wxString const &)*arg2);
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 resultobj = SWIG_Py_Void();
37076 {
37077 if (temp2)
37078 delete arg2;
37079 }
37080 return resultobj;
37081 fail:
37082 {
37083 if (temp2)
37084 delete arg2;
37085 }
37086 return NULL;
37087 }
37088
37089
37090 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37091 PyObject *resultobj = 0;
37092 wxWindow *arg1 = (wxWindow *) 0 ;
37093 wxString *arg2 = 0 ;
37094 void *argp1 = 0 ;
37095 int res1 = 0 ;
37096 bool temp2 = false ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 char * kwnames[] = {
37100 (char *) "self",(char *) "text", NULL
37101 };
37102
37103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37105 if (!SWIG_IsOK(res1)) {
37106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37107 }
37108 arg1 = reinterpret_cast< wxWindow * >(argp1);
37109 {
37110 arg2 = wxString_in_helper(obj1);
37111 if (arg2 == NULL) SWIG_fail;
37112 temp2 = true;
37113 }
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 resultobj = SWIG_Py_Void();
37121 {
37122 if (temp2)
37123 delete arg2;
37124 }
37125 return resultobj;
37126 fail:
37127 {
37128 if (temp2)
37129 delete arg2;
37130 }
37131 return NULL;
37132 }
37133
37134
37135 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj = 0;
37137 wxWindow *arg1 = (wxWindow *) 0 ;
37138 wxPoint *arg2 = 0 ;
37139 wxHelpEvent::Origin arg3 ;
37140 wxString result;
37141 void *argp1 = 0 ;
37142 int res1 = 0 ;
37143 wxPoint temp2 ;
37144 void *argp3 ;
37145 int res3 = 0 ;
37146 PyObject * obj0 = 0 ;
37147 PyObject * obj1 = 0 ;
37148 PyObject * obj2 = 0 ;
37149 char * kwnames[] = {
37150 (char *) "self",(char *) "pt",(char *) "origin", NULL
37151 };
37152
37153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 {
37160 arg2 = &temp2;
37161 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37162 }
37163 {
37164 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37165 if (!SWIG_IsOK(res3)) {
37166 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37167 }
37168 if (!argp3) {
37169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37170 } else {
37171 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37172 arg3 = *temp;
37173 if (SWIG_IsNewObj(res3)) delete temp;
37174 }
37175 }
37176 {
37177 PyThreadState* __tstate = wxPyBeginAllowThreads();
37178 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37179 wxPyEndAllowThreads(__tstate);
37180 if (PyErr_Occurred()) SWIG_fail;
37181 }
37182 {
37183 #if wxUSE_UNICODE
37184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37185 #else
37186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37187 #endif
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37196 PyObject *resultobj = 0;
37197 wxWindow *arg1 = (wxWindow *) 0 ;
37198 wxString result;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 PyObject *swig_obj[1] ;
37202
37203 if (!args) SWIG_fail;
37204 swig_obj[0] = args;
37205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37206 if (!SWIG_IsOK(res1)) {
37207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37208 }
37209 arg1 = reinterpret_cast< wxWindow * >(argp1);
37210 {
37211 PyThreadState* __tstate = wxPyBeginAllowThreads();
37212 result = ((wxWindow const *)arg1)->GetHelpText();
37213 wxPyEndAllowThreads(__tstate);
37214 if (PyErr_Occurred()) SWIG_fail;
37215 }
37216 {
37217 #if wxUSE_UNICODE
37218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37219 #else
37220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37221 #endif
37222 }
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37230 PyObject *resultobj = 0;
37231 wxWindow *arg1 = (wxWindow *) 0 ;
37232 wxString *arg2 = 0 ;
37233 void *argp1 = 0 ;
37234 int res1 = 0 ;
37235 bool temp2 = false ;
37236 PyObject * obj0 = 0 ;
37237 PyObject * obj1 = 0 ;
37238 char * kwnames[] = {
37239 (char *) "self",(char *) "tip", NULL
37240 };
37241
37242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37244 if (!SWIG_IsOK(res1)) {
37245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37246 }
37247 arg1 = reinterpret_cast< wxWindow * >(argp1);
37248 {
37249 arg2 = wxString_in_helper(obj1);
37250 if (arg2 == NULL) SWIG_fail;
37251 temp2 = true;
37252 }
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 (arg1)->SetToolTip((wxString const &)*arg2);
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 resultobj = SWIG_Py_Void();
37260 {
37261 if (temp2)
37262 delete arg2;
37263 }
37264 return resultobj;
37265 fail:
37266 {
37267 if (temp2)
37268 delete arg2;
37269 }
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 wxToolTip *arg2 = (wxToolTip *) 0 ;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 int res2 = 0 ;
37281 PyObject * obj0 = 0 ;
37282 PyObject * obj1 = 0 ;
37283 char * kwnames[] = {
37284 (char *) "self",(char *) "tip", NULL
37285 };
37286
37287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37289 if (!SWIG_IsOK(res1)) {
37290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37291 }
37292 arg1 = reinterpret_cast< wxWindow * >(argp1);
37293 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37294 if (!SWIG_IsOK(res2)) {
37295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37296 }
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 (arg1)->SetToolTip(arg2);
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 resultobj = SWIG_Py_Void();
37304 return resultobj;
37305 fail:
37306 return NULL;
37307 }
37308
37309
37310 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37311 PyObject *resultobj = 0;
37312 wxWindow *arg1 = (wxWindow *) 0 ;
37313 wxToolTip *result = 0 ;
37314 void *argp1 = 0 ;
37315 int res1 = 0 ;
37316 PyObject *swig_obj[1] ;
37317
37318 if (!args) SWIG_fail;
37319 swig_obj[0] = args;
37320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37321 if (!SWIG_IsOK(res1)) {
37322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37323 }
37324 arg1 = reinterpret_cast< wxWindow * >(argp1);
37325 {
37326 PyThreadState* __tstate = wxPyBeginAllowThreads();
37327 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37328 wxPyEndAllowThreads(__tstate);
37329 if (PyErr_Occurred()) SWIG_fail;
37330 }
37331 {
37332 resultobj = wxPyMake_wxObject(result, (bool)0);
37333 }
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 int res2 = 0 ;
37347 PyObject * obj0 = 0 ;
37348 PyObject * obj1 = 0 ;
37349 char * kwnames[] = {
37350 (char *) "self",(char *) "dropTarget", NULL
37351 };
37352
37353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37355 if (!SWIG_IsOK(res1)) {
37356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37357 }
37358 arg1 = reinterpret_cast< wxWindow * >(argp1);
37359 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37360 if (!SWIG_IsOK(res2)) {
37361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37362 }
37363 {
37364 PyThreadState* __tstate = wxPyBeginAllowThreads();
37365 (arg1)->SetDropTarget(arg2);
37366 wxPyEndAllowThreads(__tstate);
37367 if (PyErr_Occurred()) SWIG_fail;
37368 }
37369 resultobj = SWIG_Py_Void();
37370 return resultobj;
37371 fail:
37372 return NULL;
37373 }
37374
37375
37376 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37377 PyObject *resultobj = 0;
37378 wxWindow *arg1 = (wxWindow *) 0 ;
37379 wxPyDropTarget *result = 0 ;
37380 void *argp1 = 0 ;
37381 int res1 = 0 ;
37382 PyObject *swig_obj[1] ;
37383
37384 if (!args) SWIG_fail;
37385 swig_obj[0] = args;
37386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37387 if (!SWIG_IsOK(res1)) {
37388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37389 }
37390 arg1 = reinterpret_cast< wxWindow * >(argp1);
37391 {
37392 PyThreadState* __tstate = wxPyBeginAllowThreads();
37393 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37405 PyObject *resultobj = 0;
37406 wxWindow *arg1 = (wxWindow *) 0 ;
37407 bool arg2 ;
37408 void *argp1 = 0 ;
37409 int res1 = 0 ;
37410 bool val2 ;
37411 int ecode2 = 0 ;
37412 PyObject * obj0 = 0 ;
37413 PyObject * obj1 = 0 ;
37414 char * kwnames[] = {
37415 (char *) "self",(char *) "accept", NULL
37416 };
37417
37418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37420 if (!SWIG_IsOK(res1)) {
37421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37422 }
37423 arg1 = reinterpret_cast< wxWindow * >(argp1);
37424 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37425 if (!SWIG_IsOK(ecode2)) {
37426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37427 }
37428 arg2 = static_cast< bool >(val2);
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 wxWindow_DragAcceptFiles(arg1,arg2);
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 resultobj = SWIG_Py_Void();
37436 return resultobj;
37437 fail:
37438 return NULL;
37439 }
37440
37441
37442 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37443 PyObject *resultobj = 0;
37444 wxWindow *arg1 = (wxWindow *) 0 ;
37445 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37446 void *argp1 = 0 ;
37447 int res1 = 0 ;
37448 int res2 = 0 ;
37449 PyObject * obj0 = 0 ;
37450 PyObject * obj1 = 0 ;
37451 char * kwnames[] = {
37452 (char *) "self",(char *) "constraints", NULL
37453 };
37454
37455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37457 if (!SWIG_IsOK(res1)) {
37458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37459 }
37460 arg1 = reinterpret_cast< wxWindow * >(argp1);
37461 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37462 if (!SWIG_IsOK(res2)) {
37463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37464 }
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 (arg1)->SetConstraints(arg2);
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 resultobj = SWIG_Py_Void();
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37479 PyObject *resultobj = 0;
37480 wxWindow *arg1 = (wxWindow *) 0 ;
37481 wxLayoutConstraints *result = 0 ;
37482 void *argp1 = 0 ;
37483 int res1 = 0 ;
37484 PyObject *swig_obj[1] ;
37485
37486 if (!args) SWIG_fail;
37487 swig_obj[0] = args;
37488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 {
37494 PyThreadState* __tstate = wxPyBeginAllowThreads();
37495 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37496 wxPyEndAllowThreads(__tstate);
37497 if (PyErr_Occurred()) SWIG_fail;
37498 }
37499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37500 return resultobj;
37501 fail:
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37507 PyObject *resultobj = 0;
37508 wxWindow *arg1 = (wxWindow *) 0 ;
37509 bool arg2 ;
37510 void *argp1 = 0 ;
37511 int res1 = 0 ;
37512 bool val2 ;
37513 int ecode2 = 0 ;
37514 PyObject * obj0 = 0 ;
37515 PyObject * obj1 = 0 ;
37516 char * kwnames[] = {
37517 (char *) "self",(char *) "autoLayout", NULL
37518 };
37519
37520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37522 if (!SWIG_IsOK(res1)) {
37523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37524 }
37525 arg1 = reinterpret_cast< wxWindow * >(argp1);
37526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37527 if (!SWIG_IsOK(ecode2)) {
37528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37529 }
37530 arg2 = static_cast< bool >(val2);
37531 {
37532 PyThreadState* __tstate = wxPyBeginAllowThreads();
37533 (arg1)->SetAutoLayout(arg2);
37534 wxPyEndAllowThreads(__tstate);
37535 if (PyErr_Occurred()) SWIG_fail;
37536 }
37537 resultobj = SWIG_Py_Void();
37538 return resultobj;
37539 fail:
37540 return NULL;
37541 }
37542
37543
37544 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37545 PyObject *resultobj = 0;
37546 wxWindow *arg1 = (wxWindow *) 0 ;
37547 bool result;
37548 void *argp1 = 0 ;
37549 int res1 = 0 ;
37550 PyObject *swig_obj[1] ;
37551
37552 if (!args) SWIG_fail;
37553 swig_obj[0] = args;
37554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37555 if (!SWIG_IsOK(res1)) {
37556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37557 }
37558 arg1 = reinterpret_cast< wxWindow * >(argp1);
37559 {
37560 PyThreadState* __tstate = wxPyBeginAllowThreads();
37561 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37562 wxPyEndAllowThreads(__tstate);
37563 if (PyErr_Occurred()) SWIG_fail;
37564 }
37565 {
37566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37567 }
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37575 PyObject *resultobj = 0;
37576 wxWindow *arg1 = (wxWindow *) 0 ;
37577 bool result;
37578 void *argp1 = 0 ;
37579 int res1 = 0 ;
37580 PyObject *swig_obj[1] ;
37581
37582 if (!args) SWIG_fail;
37583 swig_obj[0] = args;
37584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37585 if (!SWIG_IsOK(res1)) {
37586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37587 }
37588 arg1 = reinterpret_cast< wxWindow * >(argp1);
37589 {
37590 PyThreadState* __tstate = wxPyBeginAllowThreads();
37591 result = (bool)(arg1)->Layout();
37592 wxPyEndAllowThreads(__tstate);
37593 if (PyErr_Occurred()) SWIG_fail;
37594 }
37595 {
37596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37597 }
37598 return resultobj;
37599 fail:
37600 return NULL;
37601 }
37602
37603
37604 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37605 PyObject *resultobj = 0;
37606 wxWindow *arg1 = (wxWindow *) 0 ;
37607 wxSizer *arg2 = (wxSizer *) 0 ;
37608 bool arg3 = (bool) true ;
37609 void *argp1 = 0 ;
37610 int res1 = 0 ;
37611 int res2 = 0 ;
37612 bool val3 ;
37613 int ecode3 = 0 ;
37614 PyObject * obj0 = 0 ;
37615 PyObject * obj1 = 0 ;
37616 PyObject * obj2 = 0 ;
37617 char * kwnames[] = {
37618 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37619 };
37620
37621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37623 if (!SWIG_IsOK(res1)) {
37624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37625 }
37626 arg1 = reinterpret_cast< wxWindow * >(argp1);
37627 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37628 if (!SWIG_IsOK(res2)) {
37629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37630 }
37631 if (obj2) {
37632 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37633 if (!SWIG_IsOK(ecode3)) {
37634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37635 }
37636 arg3 = static_cast< bool >(val3);
37637 }
37638 {
37639 PyThreadState* __tstate = wxPyBeginAllowThreads();
37640 (arg1)->SetSizer(arg2,arg3);
37641 wxPyEndAllowThreads(__tstate);
37642 if (PyErr_Occurred()) SWIG_fail;
37643 }
37644 resultobj = SWIG_Py_Void();
37645 return resultobj;
37646 fail:
37647 return NULL;
37648 }
37649
37650
37651 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37652 PyObject *resultobj = 0;
37653 wxWindow *arg1 = (wxWindow *) 0 ;
37654 wxSizer *arg2 = (wxSizer *) 0 ;
37655 bool arg3 = (bool) true ;
37656 void *argp1 = 0 ;
37657 int res1 = 0 ;
37658 int res2 = 0 ;
37659 bool val3 ;
37660 int ecode3 = 0 ;
37661 PyObject * obj0 = 0 ;
37662 PyObject * obj1 = 0 ;
37663 PyObject * obj2 = 0 ;
37664 char * kwnames[] = {
37665 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37666 };
37667
37668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37670 if (!SWIG_IsOK(res1)) {
37671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37672 }
37673 arg1 = reinterpret_cast< wxWindow * >(argp1);
37674 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37675 if (!SWIG_IsOK(res2)) {
37676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37677 }
37678 if (obj2) {
37679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37680 if (!SWIG_IsOK(ecode3)) {
37681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37682 }
37683 arg3 = static_cast< bool >(val3);
37684 }
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 (arg1)->SetSizerAndFit(arg2,arg3);
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 resultobj = SWIG_Py_Void();
37692 return resultobj;
37693 fail:
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37699 PyObject *resultobj = 0;
37700 wxWindow *arg1 = (wxWindow *) 0 ;
37701 wxSizer *result = 0 ;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 PyObject *swig_obj[1] ;
37705
37706 if (!args) SWIG_fail;
37707 swig_obj[0] = args;
37708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37709 if (!SWIG_IsOK(res1)) {
37710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37711 }
37712 arg1 = reinterpret_cast< wxWindow * >(argp1);
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 {
37720 resultobj = wxPyMake_wxObject(result, (bool)0);
37721 }
37722 return resultobj;
37723 fail:
37724 return NULL;
37725 }
37726
37727
37728 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37729 PyObject *resultobj = 0;
37730 wxWindow *arg1 = (wxWindow *) 0 ;
37731 wxSizer *arg2 = (wxSizer *) 0 ;
37732 void *argp1 = 0 ;
37733 int res1 = 0 ;
37734 void *argp2 = 0 ;
37735 int res2 = 0 ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char * kwnames[] = {
37739 (char *) "self",(char *) "sizer", NULL
37740 };
37741
37742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37744 if (!SWIG_IsOK(res1)) {
37745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37746 }
37747 arg1 = reinterpret_cast< wxWindow * >(argp1);
37748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37749 if (!SWIG_IsOK(res2)) {
37750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37751 }
37752 arg2 = reinterpret_cast< wxSizer * >(argp2);
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 (arg1)->SetContainingSizer(arg2);
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = SWIG_Py_Void();
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 wxSizer *result = 0 ;
37770 void *argp1 = 0 ;
37771 int res1 = 0 ;
37772 PyObject *swig_obj[1] ;
37773
37774 if (!args) SWIG_fail;
37775 swig_obj[0] = args;
37776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37777 if (!SWIG_IsOK(res1)) {
37778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37779 }
37780 arg1 = reinterpret_cast< wxWindow * >(argp1);
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 {
37788 resultobj = wxPyMake_wxObject(result, (bool)0);
37789 }
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 PyObject *resultobj = 0;
37798 wxWindow *arg1 = (wxWindow *) 0 ;
37799 void *argp1 = 0 ;
37800 int res1 = 0 ;
37801 PyObject *swig_obj[1] ;
37802
37803 if (!args) SWIG_fail;
37804 swig_obj[0] = args;
37805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37806 if (!SWIG_IsOK(res1)) {
37807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37808 }
37809 arg1 = reinterpret_cast< wxWindow * >(argp1);
37810 {
37811 PyThreadState* __tstate = wxPyBeginAllowThreads();
37812 (arg1)->InheritAttributes();
37813 wxPyEndAllowThreads(__tstate);
37814 if (PyErr_Occurred()) SWIG_fail;
37815 }
37816 resultobj = SWIG_Py_Void();
37817 return resultobj;
37818 fail:
37819 return NULL;
37820 }
37821
37822
37823 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37824 PyObject *resultobj = 0;
37825 wxWindow *arg1 = (wxWindow *) 0 ;
37826 bool result;
37827 void *argp1 = 0 ;
37828 int res1 = 0 ;
37829 PyObject *swig_obj[1] ;
37830
37831 if (!args) SWIG_fail;
37832 swig_obj[0] = args;
37833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37834 if (!SWIG_IsOK(res1)) {
37835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37836 }
37837 arg1 = reinterpret_cast< wxWindow * >(argp1);
37838 {
37839 PyThreadState* __tstate = wxPyBeginAllowThreads();
37840 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37841 wxPyEndAllowThreads(__tstate);
37842 if (PyErr_Occurred()) SWIG_fail;
37843 }
37844 {
37845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37846 }
37847 return resultobj;
37848 fail:
37849 return NULL;
37850 }
37851
37852
37853 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37854 PyObject *resultobj = 0;
37855 wxWindow *arg1 = (wxWindow *) 0 ;
37856 bool result;
37857 void *argp1 = 0 ;
37858 int res1 = 0 ;
37859 PyObject *swig_obj[1] ;
37860
37861 if (!args) SWIG_fail;
37862 swig_obj[0] = args;
37863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37864 if (!SWIG_IsOK(res1)) {
37865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37866 }
37867 arg1 = reinterpret_cast< wxWindow * >(argp1);
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 result = (bool)(arg1)->CanSetTransparent();
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 {
37875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37876 }
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj = 0;
37885 wxWindow *arg1 = (wxWindow *) 0 ;
37886 byte arg2 ;
37887 bool result;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 unsigned char val2 ;
37891 int ecode2 = 0 ;
37892 PyObject * obj0 = 0 ;
37893 PyObject * obj1 = 0 ;
37894 char * kwnames[] = {
37895 (char *) "self",(char *) "alpha", NULL
37896 };
37897
37898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37900 if (!SWIG_IsOK(res1)) {
37901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37902 }
37903 arg1 = reinterpret_cast< wxWindow * >(argp1);
37904 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37905 if (!SWIG_IsOK(ecode2)) {
37906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37907 }
37908 arg2 = static_cast< byte >(val2);
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 result = (bool)(arg1)->SetTransparent(arg2);
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 {
37916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37917 }
37918 return resultobj;
37919 fail:
37920 return NULL;
37921 }
37922
37923
37924 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37925 PyObject *obj;
37926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37927 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37928 return SWIG_Py_Void();
37929 }
37930
37931 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37932 return SWIG_Python_InitShadowInstance(args);
37933 }
37934
37935 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37936 PyObject *resultobj = 0;
37937 long arg1 ;
37938 wxWindow *arg2 = (wxWindow *) NULL ;
37939 wxWindow *result = 0 ;
37940 long val1 ;
37941 int ecode1 = 0 ;
37942 void *argp2 = 0 ;
37943 int res2 = 0 ;
37944 PyObject * obj0 = 0 ;
37945 PyObject * obj1 = 0 ;
37946 char * kwnames[] = {
37947 (char *) "id",(char *) "parent", NULL
37948 };
37949
37950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37951 ecode1 = SWIG_AsVal_long(obj0, &val1);
37952 if (!SWIG_IsOK(ecode1)) {
37953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37954 }
37955 arg1 = static_cast< long >(val1);
37956 if (obj1) {
37957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37958 if (!SWIG_IsOK(res2)) {
37959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37960 }
37961 arg2 = reinterpret_cast< wxWindow * >(argp2);
37962 }
37963 {
37964 if (!wxPyCheckForApp()) SWIG_fail;
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37967 wxPyEndAllowThreads(__tstate);
37968 if (PyErr_Occurred()) SWIG_fail;
37969 }
37970 {
37971 resultobj = wxPyMake_wxObject(result, 0);
37972 }
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj = 0;
37981 wxString *arg1 = 0 ;
37982 wxWindow *arg2 = (wxWindow *) NULL ;
37983 wxWindow *result = 0 ;
37984 bool temp1 = false ;
37985 void *argp2 = 0 ;
37986 int res2 = 0 ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 char * kwnames[] = {
37990 (char *) "name",(char *) "parent", NULL
37991 };
37992
37993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37994 {
37995 arg1 = wxString_in_helper(obj0);
37996 if (arg1 == NULL) SWIG_fail;
37997 temp1 = true;
37998 }
37999 if (obj1) {
38000 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38001 if (!SWIG_IsOK(res2)) {
38002 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38003 }
38004 arg2 = reinterpret_cast< wxWindow * >(argp2);
38005 }
38006 {
38007 if (!wxPyCheckForApp()) SWIG_fail;
38008 PyThreadState* __tstate = wxPyBeginAllowThreads();
38009 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 {
38014 resultobj = wxPyMake_wxObject(result, 0);
38015 }
38016 {
38017 if (temp1)
38018 delete arg1;
38019 }
38020 return resultobj;
38021 fail:
38022 {
38023 if (temp1)
38024 delete arg1;
38025 }
38026 return NULL;
38027 }
38028
38029
38030 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38031 PyObject *resultobj = 0;
38032 wxString *arg1 = 0 ;
38033 wxWindow *arg2 = (wxWindow *) NULL ;
38034 wxWindow *result = 0 ;
38035 bool temp1 = false ;
38036 void *argp2 = 0 ;
38037 int res2 = 0 ;
38038 PyObject * obj0 = 0 ;
38039 PyObject * obj1 = 0 ;
38040 char * kwnames[] = {
38041 (char *) "label",(char *) "parent", NULL
38042 };
38043
38044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38045 {
38046 arg1 = wxString_in_helper(obj0);
38047 if (arg1 == NULL) SWIG_fail;
38048 temp1 = true;
38049 }
38050 if (obj1) {
38051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38052 if (!SWIG_IsOK(res2)) {
38053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38054 }
38055 arg2 = reinterpret_cast< wxWindow * >(argp2);
38056 }
38057 {
38058 if (!wxPyCheckForApp()) SWIG_fail;
38059 PyThreadState* __tstate = wxPyBeginAllowThreads();
38060 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38061 wxPyEndAllowThreads(__tstate);
38062 if (PyErr_Occurred()) SWIG_fail;
38063 }
38064 {
38065 resultobj = wxPyMake_wxObject(result, 0);
38066 }
38067 {
38068 if (temp1)
38069 delete arg1;
38070 }
38071 return resultobj;
38072 fail:
38073 {
38074 if (temp1)
38075 delete arg1;
38076 }
38077 return NULL;
38078 }
38079
38080
38081 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38082 PyObject *resultobj = 0;
38083 wxWindow *arg1 = (wxWindow *) 0 ;
38084 unsigned long arg2 ;
38085 wxWindow *result = 0 ;
38086 void *argp1 = 0 ;
38087 int res1 = 0 ;
38088 unsigned long val2 ;
38089 int ecode2 = 0 ;
38090 PyObject * obj0 = 0 ;
38091 PyObject * obj1 = 0 ;
38092 char * kwnames[] = {
38093 (char *) "parent",(char *) "_hWnd", NULL
38094 };
38095
38096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38098 if (!SWIG_IsOK(res1)) {
38099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38100 }
38101 arg1 = reinterpret_cast< wxWindow * >(argp1);
38102 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38103 if (!SWIG_IsOK(ecode2)) {
38104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38105 }
38106 arg2 = static_cast< unsigned long >(val2);
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 {
38114 resultobj = wxPyMake_wxObject(result, 0);
38115 }
38116 return resultobj;
38117 fail:
38118 return NULL;
38119 }
38120
38121
38122 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38123 PyObject *resultobj = 0;
38124 PyObject *result = 0 ;
38125
38126 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 result = (PyObject *)GetTopLevelWindows();
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 resultobj = result;
38134 return resultobj;
38135 fail:
38136 return NULL;
38137 }
38138
38139
38140 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 PyObject *resultobj = 0;
38142 wxValidator *result = 0 ;
38143
38144 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38145 {
38146 PyThreadState* __tstate = wxPyBeginAllowThreads();
38147 result = (wxValidator *)new wxValidator();
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38152 return resultobj;
38153 fail:
38154 return NULL;
38155 }
38156
38157
38158 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38159 PyObject *resultobj = 0;
38160 wxValidator *arg1 = (wxValidator *) 0 ;
38161 wxValidator *result = 0 ;
38162 void *argp1 = 0 ;
38163 int res1 = 0 ;
38164 PyObject *swig_obj[1] ;
38165
38166 if (!args) SWIG_fail;
38167 swig_obj[0] = args;
38168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38169 if (!SWIG_IsOK(res1)) {
38170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38171 }
38172 arg1 = reinterpret_cast< wxValidator * >(argp1);
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 result = (wxValidator *)(arg1)->Clone();
38176 wxPyEndAllowThreads(__tstate);
38177 if (PyErr_Occurred()) SWIG_fail;
38178 }
38179 {
38180 resultobj = wxPyMake_wxObject(result, 0);
38181 }
38182 return resultobj;
38183 fail:
38184 return NULL;
38185 }
38186
38187
38188 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38189 PyObject *resultobj = 0;
38190 wxValidator *arg1 = (wxValidator *) 0 ;
38191 wxWindow *arg2 = (wxWindow *) 0 ;
38192 bool result;
38193 void *argp1 = 0 ;
38194 int res1 = 0 ;
38195 void *argp2 = 0 ;
38196 int res2 = 0 ;
38197 PyObject * obj0 = 0 ;
38198 PyObject * obj1 = 0 ;
38199 char * kwnames[] = {
38200 (char *) "self",(char *) "parent", NULL
38201 };
38202
38203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38205 if (!SWIG_IsOK(res1)) {
38206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38207 }
38208 arg1 = reinterpret_cast< wxValidator * >(argp1);
38209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38210 if (!SWIG_IsOK(res2)) {
38211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38212 }
38213 arg2 = reinterpret_cast< wxWindow * >(argp2);
38214 {
38215 PyThreadState* __tstate = wxPyBeginAllowThreads();
38216 result = (bool)(arg1)->Validate(arg2);
38217 wxPyEndAllowThreads(__tstate);
38218 if (PyErr_Occurred()) SWIG_fail;
38219 }
38220 {
38221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38222 }
38223 return resultobj;
38224 fail:
38225 return NULL;
38226 }
38227
38228
38229 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38230 PyObject *resultobj = 0;
38231 wxValidator *arg1 = (wxValidator *) 0 ;
38232 bool result;
38233 void *argp1 = 0 ;
38234 int res1 = 0 ;
38235 PyObject *swig_obj[1] ;
38236
38237 if (!args) SWIG_fail;
38238 swig_obj[0] = args;
38239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38242 }
38243 arg1 = reinterpret_cast< wxValidator * >(argp1);
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (bool)(arg1)->TransferToWindow();
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38252 }
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38260 PyObject *resultobj = 0;
38261 wxValidator *arg1 = (wxValidator *) 0 ;
38262 bool result;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 PyObject *swig_obj[1] ;
38266
38267 if (!args) SWIG_fail;
38268 swig_obj[0] = args;
38269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38270 if (!SWIG_IsOK(res1)) {
38271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38272 }
38273 arg1 = reinterpret_cast< wxValidator * >(argp1);
38274 {
38275 PyThreadState* __tstate = wxPyBeginAllowThreads();
38276 result = (bool)(arg1)->TransferFromWindow();
38277 wxPyEndAllowThreads(__tstate);
38278 if (PyErr_Occurred()) SWIG_fail;
38279 }
38280 {
38281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38282 }
38283 return resultobj;
38284 fail:
38285 return NULL;
38286 }
38287
38288
38289 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38290 PyObject *resultobj = 0;
38291 wxValidator *arg1 = (wxValidator *) 0 ;
38292 wxWindow *result = 0 ;
38293 void *argp1 = 0 ;
38294 int res1 = 0 ;
38295 PyObject *swig_obj[1] ;
38296
38297 if (!args) SWIG_fail;
38298 swig_obj[0] = args;
38299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38300 if (!SWIG_IsOK(res1)) {
38301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38302 }
38303 arg1 = reinterpret_cast< wxValidator * >(argp1);
38304 {
38305 PyThreadState* __tstate = wxPyBeginAllowThreads();
38306 result = (wxWindow *)(arg1)->GetWindow();
38307 wxPyEndAllowThreads(__tstate);
38308 if (PyErr_Occurred()) SWIG_fail;
38309 }
38310 {
38311 resultobj = wxPyMake_wxObject(result, 0);
38312 }
38313 return resultobj;
38314 fail:
38315 return NULL;
38316 }
38317
38318
38319 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38320 PyObject *resultobj = 0;
38321 wxValidator *arg1 = (wxValidator *) 0 ;
38322 wxWindow *arg2 = (wxWindow *) 0 ;
38323 void *argp1 = 0 ;
38324 int res1 = 0 ;
38325 void *argp2 = 0 ;
38326 int res2 = 0 ;
38327 PyObject * obj0 = 0 ;
38328 PyObject * obj1 = 0 ;
38329 char * kwnames[] = {
38330 (char *) "self",(char *) "window", NULL
38331 };
38332
38333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38335 if (!SWIG_IsOK(res1)) {
38336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38337 }
38338 arg1 = reinterpret_cast< wxValidator * >(argp1);
38339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38340 if (!SWIG_IsOK(res2)) {
38341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38342 }
38343 arg2 = reinterpret_cast< wxWindow * >(argp2);
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 (arg1)->SetWindow(arg2);
38347 wxPyEndAllowThreads(__tstate);
38348 if (PyErr_Occurred()) SWIG_fail;
38349 }
38350 resultobj = SWIG_Py_Void();
38351 return resultobj;
38352 fail:
38353 return NULL;
38354 }
38355
38356
38357 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38358 PyObject *resultobj = 0;
38359 bool result;
38360
38361 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38362 {
38363 PyThreadState* __tstate = wxPyBeginAllowThreads();
38364 result = (bool)wxValidator::IsSilent();
38365 wxPyEndAllowThreads(__tstate);
38366 if (PyErr_Occurred()) SWIG_fail;
38367 }
38368 {
38369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38370 }
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38378 PyObject *resultobj = 0;
38379 int arg1 = (int) true ;
38380 int val1 ;
38381 int ecode1 = 0 ;
38382 PyObject * obj0 = 0 ;
38383 char * kwnames[] = {
38384 (char *) "doIt", NULL
38385 };
38386
38387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38388 if (obj0) {
38389 ecode1 = SWIG_AsVal_int(obj0, &val1);
38390 if (!SWIG_IsOK(ecode1)) {
38391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38392 }
38393 arg1 = static_cast< int >(val1);
38394 }
38395 {
38396 PyThreadState* __tstate = wxPyBeginAllowThreads();
38397 wxValidator::SetBellOnError(arg1);
38398 wxPyEndAllowThreads(__tstate);
38399 if (PyErr_Occurred()) SWIG_fail;
38400 }
38401 resultobj = SWIG_Py_Void();
38402 return resultobj;
38403 fail:
38404 return NULL;
38405 }
38406
38407
38408 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38409 PyObject *obj;
38410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38411 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38412 return SWIG_Py_Void();
38413 }
38414
38415 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38416 return SWIG_Python_InitShadowInstance(args);
38417 }
38418
38419 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38420 PyObject *resultobj = 0;
38421 wxPyValidator *result = 0 ;
38422
38423 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38424 {
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (wxPyValidator *)new wxPyValidator();
38427 wxPyEndAllowThreads(__tstate);
38428 if (PyErr_Occurred()) SWIG_fail;
38429 }
38430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38431 return resultobj;
38432 fail:
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38438 PyObject *resultobj = 0;
38439 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38440 PyObject *arg2 = (PyObject *) 0 ;
38441 PyObject *arg3 = (PyObject *) 0 ;
38442 int arg4 = (int) true ;
38443 void *argp1 = 0 ;
38444 int res1 = 0 ;
38445 int val4 ;
38446 int ecode4 = 0 ;
38447 PyObject * obj0 = 0 ;
38448 PyObject * obj1 = 0 ;
38449 PyObject * obj2 = 0 ;
38450 PyObject * obj3 = 0 ;
38451 char * kwnames[] = {
38452 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38453 };
38454
38455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38457 if (!SWIG_IsOK(res1)) {
38458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38459 }
38460 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38461 arg2 = obj1;
38462 arg3 = obj2;
38463 if (obj3) {
38464 ecode4 = SWIG_AsVal_int(obj3, &val4);
38465 if (!SWIG_IsOK(ecode4)) {
38466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38467 }
38468 arg4 = static_cast< int >(val4);
38469 }
38470 {
38471 PyThreadState* __tstate = wxPyBeginAllowThreads();
38472 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38473 wxPyEndAllowThreads(__tstate);
38474 if (PyErr_Occurred()) SWIG_fail;
38475 }
38476 resultobj = SWIG_Py_Void();
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38484 PyObject *obj;
38485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38486 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38487 return SWIG_Py_Void();
38488 }
38489
38490 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38491 return SWIG_Python_InitShadowInstance(args);
38492 }
38493
38494 SWIGINTERN int DefaultValidator_set(PyObject *) {
38495 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38496 return 1;
38497 }
38498
38499
38500 SWIGINTERN PyObject *DefaultValidator_get(void) {
38501 PyObject *pyobj = 0;
38502
38503 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38504 return pyobj;
38505 }
38506
38507
38508 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38509 PyObject *resultobj = 0;
38510 wxString const &arg1_defvalue = wxPyEmptyString ;
38511 wxString *arg1 = (wxString *) &arg1_defvalue ;
38512 long arg2 = (long) 0 ;
38513 wxMenu *result = 0 ;
38514 bool temp1 = false ;
38515 long val2 ;
38516 int ecode2 = 0 ;
38517 PyObject * obj0 = 0 ;
38518 PyObject * obj1 = 0 ;
38519 char * kwnames[] = {
38520 (char *) "title",(char *) "style", NULL
38521 };
38522
38523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38524 if (obj0) {
38525 {
38526 arg1 = wxString_in_helper(obj0);
38527 if (arg1 == NULL) SWIG_fail;
38528 temp1 = true;
38529 }
38530 }
38531 if (obj1) {
38532 ecode2 = SWIG_AsVal_long(obj1, &val2);
38533 if (!SWIG_IsOK(ecode2)) {
38534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38535 }
38536 arg2 = static_cast< long >(val2);
38537 }
38538 {
38539 if (!wxPyCheckForApp()) SWIG_fail;
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38546 {
38547 if (temp1)
38548 delete arg1;
38549 }
38550 return resultobj;
38551 fail:
38552 {
38553 if (temp1)
38554 delete arg1;
38555 }
38556 return NULL;
38557 }
38558
38559
38560 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38561 PyObject *resultobj = 0;
38562 wxMenu *arg1 = (wxMenu *) 0 ;
38563 int arg2 ;
38564 wxString *arg3 = 0 ;
38565 wxString const &arg4_defvalue = wxPyEmptyString ;
38566 wxString *arg4 = (wxString *) &arg4_defvalue ;
38567 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38568 wxMenuItem *result = 0 ;
38569 void *argp1 = 0 ;
38570 int res1 = 0 ;
38571 int val2 ;
38572 int ecode2 = 0 ;
38573 bool temp3 = false ;
38574 bool temp4 = false ;
38575 int val5 ;
38576 int ecode5 = 0 ;
38577 PyObject * obj0 = 0 ;
38578 PyObject * obj1 = 0 ;
38579 PyObject * obj2 = 0 ;
38580 PyObject * obj3 = 0 ;
38581 PyObject * obj4 = 0 ;
38582 char * kwnames[] = {
38583 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38584 };
38585
38586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38590 }
38591 arg1 = reinterpret_cast< wxMenu * >(argp1);
38592 ecode2 = SWIG_AsVal_int(obj1, &val2);
38593 if (!SWIG_IsOK(ecode2)) {
38594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38595 }
38596 arg2 = static_cast< int >(val2);
38597 {
38598 arg3 = wxString_in_helper(obj2);
38599 if (arg3 == NULL) SWIG_fail;
38600 temp3 = true;
38601 }
38602 if (obj3) {
38603 {
38604 arg4 = wxString_in_helper(obj3);
38605 if (arg4 == NULL) SWIG_fail;
38606 temp4 = true;
38607 }
38608 }
38609 if (obj4) {
38610 ecode5 = SWIG_AsVal_int(obj4, &val5);
38611 if (!SWIG_IsOK(ecode5)) {
38612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38613 }
38614 arg5 = static_cast< wxItemKind >(val5);
38615 }
38616 {
38617 PyThreadState* __tstate = wxPyBeginAllowThreads();
38618 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38619 wxPyEndAllowThreads(__tstate);
38620 if (PyErr_Occurred()) SWIG_fail;
38621 }
38622 {
38623 resultobj = wxPyMake_wxObject(result, (bool)0);
38624 }
38625 {
38626 if (temp3)
38627 delete arg3;
38628 }
38629 {
38630 if (temp4)
38631 delete arg4;
38632 }
38633 return resultobj;
38634 fail:
38635 {
38636 if (temp3)
38637 delete arg3;
38638 }
38639 {
38640 if (temp4)
38641 delete arg4;
38642 }
38643 return NULL;
38644 }
38645
38646
38647 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38648 PyObject *resultobj = 0;
38649 wxMenu *arg1 = (wxMenu *) 0 ;
38650 wxMenuItem *result = 0 ;
38651 void *argp1 = 0 ;
38652 int res1 = 0 ;
38653 PyObject *swig_obj[1] ;
38654
38655 if (!args) SWIG_fail;
38656 swig_obj[0] = args;
38657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38658 if (!SWIG_IsOK(res1)) {
38659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38660 }
38661 arg1 = reinterpret_cast< wxMenu * >(argp1);
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 result = (wxMenuItem *)(arg1)->AppendSeparator();
38665 wxPyEndAllowThreads(__tstate);
38666 if (PyErr_Occurred()) SWIG_fail;
38667 }
38668 {
38669 resultobj = wxPyMake_wxObject(result, (bool)0);
38670 }
38671 return resultobj;
38672 fail:
38673 return NULL;
38674 }
38675
38676
38677 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38678 PyObject *resultobj = 0;
38679 wxMenu *arg1 = (wxMenu *) 0 ;
38680 int arg2 ;
38681 wxString *arg3 = 0 ;
38682 wxString const &arg4_defvalue = wxPyEmptyString ;
38683 wxString *arg4 = (wxString *) &arg4_defvalue ;
38684 wxMenuItem *result = 0 ;
38685 void *argp1 = 0 ;
38686 int res1 = 0 ;
38687 int val2 ;
38688 int ecode2 = 0 ;
38689 bool temp3 = false ;
38690 bool temp4 = false ;
38691 PyObject * obj0 = 0 ;
38692 PyObject * obj1 = 0 ;
38693 PyObject * obj2 = 0 ;
38694 PyObject * obj3 = 0 ;
38695 char * kwnames[] = {
38696 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38697 };
38698
38699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38701 if (!SWIG_IsOK(res1)) {
38702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38703 }
38704 arg1 = reinterpret_cast< wxMenu * >(argp1);
38705 ecode2 = SWIG_AsVal_int(obj1, &val2);
38706 if (!SWIG_IsOK(ecode2)) {
38707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38708 }
38709 arg2 = static_cast< int >(val2);
38710 {
38711 arg3 = wxString_in_helper(obj2);
38712 if (arg3 == NULL) SWIG_fail;
38713 temp3 = true;
38714 }
38715 if (obj3) {
38716 {
38717 arg4 = wxString_in_helper(obj3);
38718 if (arg4 == NULL) SWIG_fail;
38719 temp4 = true;
38720 }
38721 }
38722 {
38723 PyThreadState* __tstate = wxPyBeginAllowThreads();
38724 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 {
38729 resultobj = wxPyMake_wxObject(result, (bool)0);
38730 }
38731 {
38732 if (temp3)
38733 delete arg3;
38734 }
38735 {
38736 if (temp4)
38737 delete arg4;
38738 }
38739 return resultobj;
38740 fail:
38741 {
38742 if (temp3)
38743 delete arg3;
38744 }
38745 {
38746 if (temp4)
38747 delete arg4;
38748 }
38749 return NULL;
38750 }
38751
38752
38753 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38754 PyObject *resultobj = 0;
38755 wxMenu *arg1 = (wxMenu *) 0 ;
38756 int arg2 ;
38757 wxString *arg3 = 0 ;
38758 wxString const &arg4_defvalue = wxPyEmptyString ;
38759 wxString *arg4 = (wxString *) &arg4_defvalue ;
38760 wxMenuItem *result = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 int val2 ;
38764 int ecode2 = 0 ;
38765 bool temp3 = false ;
38766 bool temp4 = false ;
38767 PyObject * obj0 = 0 ;
38768 PyObject * obj1 = 0 ;
38769 PyObject * obj2 = 0 ;
38770 PyObject * obj3 = 0 ;
38771 char * kwnames[] = {
38772 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38773 };
38774
38775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38777 if (!SWIG_IsOK(res1)) {
38778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38779 }
38780 arg1 = reinterpret_cast< wxMenu * >(argp1);
38781 ecode2 = SWIG_AsVal_int(obj1, &val2);
38782 if (!SWIG_IsOK(ecode2)) {
38783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38784 }
38785 arg2 = static_cast< int >(val2);
38786 {
38787 arg3 = wxString_in_helper(obj2);
38788 if (arg3 == NULL) SWIG_fail;
38789 temp3 = true;
38790 }
38791 if (obj3) {
38792 {
38793 arg4 = wxString_in_helper(obj3);
38794 if (arg4 == NULL) SWIG_fail;
38795 temp4 = true;
38796 }
38797 }
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38801 wxPyEndAllowThreads(__tstate);
38802 if (PyErr_Occurred()) SWIG_fail;
38803 }
38804 {
38805 resultobj = wxPyMake_wxObject(result, (bool)0);
38806 }
38807 {
38808 if (temp3)
38809 delete arg3;
38810 }
38811 {
38812 if (temp4)
38813 delete arg4;
38814 }
38815 return resultobj;
38816 fail:
38817 {
38818 if (temp3)
38819 delete arg3;
38820 }
38821 {
38822 if (temp4)
38823 delete arg4;
38824 }
38825 return NULL;
38826 }
38827
38828
38829 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38830 PyObject *resultobj = 0;
38831 wxMenu *arg1 = (wxMenu *) 0 ;
38832 int arg2 ;
38833 wxString *arg3 = 0 ;
38834 wxMenu *arg4 = (wxMenu *) 0 ;
38835 wxString const &arg5_defvalue = wxPyEmptyString ;
38836 wxString *arg5 = (wxString *) &arg5_defvalue ;
38837 wxMenuItem *result = 0 ;
38838 void *argp1 = 0 ;
38839 int res1 = 0 ;
38840 int val2 ;
38841 int ecode2 = 0 ;
38842 bool temp3 = false ;
38843 void *argp4 = 0 ;
38844 int res4 = 0 ;
38845 bool temp5 = false ;
38846 PyObject * obj0 = 0 ;
38847 PyObject * obj1 = 0 ;
38848 PyObject * obj2 = 0 ;
38849 PyObject * obj3 = 0 ;
38850 PyObject * obj4 = 0 ;
38851 char * kwnames[] = {
38852 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38853 };
38854
38855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38857 if (!SWIG_IsOK(res1)) {
38858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38859 }
38860 arg1 = reinterpret_cast< wxMenu * >(argp1);
38861 ecode2 = SWIG_AsVal_int(obj1, &val2);
38862 if (!SWIG_IsOK(ecode2)) {
38863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38864 }
38865 arg2 = static_cast< int >(val2);
38866 {
38867 arg3 = wxString_in_helper(obj2);
38868 if (arg3 == NULL) SWIG_fail;
38869 temp3 = true;
38870 }
38871 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38872 if (!SWIG_IsOK(res4)) {
38873 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38874 }
38875 arg4 = reinterpret_cast< wxMenu * >(argp4);
38876 if (obj4) {
38877 {
38878 arg5 = wxString_in_helper(obj4);
38879 if (arg5 == NULL) SWIG_fail;
38880 temp5 = true;
38881 }
38882 }
38883 {
38884 PyThreadState* __tstate = wxPyBeginAllowThreads();
38885 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38886 wxPyEndAllowThreads(__tstate);
38887 if (PyErr_Occurred()) SWIG_fail;
38888 }
38889 {
38890 resultobj = wxPyMake_wxObject(result, (bool)0);
38891 }
38892 {
38893 if (temp3)
38894 delete arg3;
38895 }
38896 {
38897 if (temp5)
38898 delete arg5;
38899 }
38900 return resultobj;
38901 fail:
38902 {
38903 if (temp3)
38904 delete arg3;
38905 }
38906 {
38907 if (temp5)
38908 delete arg5;
38909 }
38910 return NULL;
38911 }
38912
38913
38914 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38915 PyObject *resultobj = 0;
38916 wxMenu *arg1 = (wxMenu *) 0 ;
38917 wxMenu *arg2 = (wxMenu *) 0 ;
38918 wxString *arg3 = 0 ;
38919 wxString const &arg4_defvalue = wxPyEmptyString ;
38920 wxString *arg4 = (wxString *) &arg4_defvalue ;
38921 wxMenuItem *result = 0 ;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 void *argp2 = 0 ;
38925 int res2 = 0 ;
38926 bool temp3 = false ;
38927 bool temp4 = false ;
38928 PyObject * obj0 = 0 ;
38929 PyObject * obj1 = 0 ;
38930 PyObject * obj2 = 0 ;
38931 PyObject * obj3 = 0 ;
38932 char * kwnames[] = {
38933 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38934 };
38935
38936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38938 if (!SWIG_IsOK(res1)) {
38939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38940 }
38941 arg1 = reinterpret_cast< wxMenu * >(argp1);
38942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38943 if (!SWIG_IsOK(res2)) {
38944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38945 }
38946 arg2 = reinterpret_cast< wxMenu * >(argp2);
38947 {
38948 arg3 = wxString_in_helper(obj2);
38949 if (arg3 == NULL) SWIG_fail;
38950 temp3 = true;
38951 }
38952 if (obj3) {
38953 {
38954 arg4 = wxString_in_helper(obj3);
38955 if (arg4 == NULL) SWIG_fail;
38956 temp4 = true;
38957 }
38958 }
38959 {
38960 PyThreadState* __tstate = wxPyBeginAllowThreads();
38961 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38962 wxPyEndAllowThreads(__tstate);
38963 if (PyErr_Occurred()) SWIG_fail;
38964 }
38965 {
38966 resultobj = wxPyMake_wxObject(result, (bool)0);
38967 }
38968 {
38969 if (temp3)
38970 delete arg3;
38971 }
38972 {
38973 if (temp4)
38974 delete arg4;
38975 }
38976 return resultobj;
38977 fail:
38978 {
38979 if (temp3)
38980 delete arg3;
38981 }
38982 {
38983 if (temp4)
38984 delete arg4;
38985 }
38986 return NULL;
38987 }
38988
38989
38990 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj = 0;
38992 wxMenu *arg1 = (wxMenu *) 0 ;
38993 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38994 wxMenuItem *result = 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 int res2 = 0 ;
38998 PyObject * obj0 = 0 ;
38999 PyObject * obj1 = 0 ;
39000 char * kwnames[] = {
39001 (char *) "self",(char *) "item", NULL
39002 };
39003
39004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39006 if (!SWIG_IsOK(res1)) {
39007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39008 }
39009 arg1 = reinterpret_cast< wxMenu * >(argp1);
39010 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39011 if (!SWIG_IsOK(res2)) {
39012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39013 }
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 result = (wxMenuItem *)(arg1)->Append(arg2);
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 {
39021 resultobj = wxPyMake_wxObject(result, (bool)0);
39022 }
39023 return resultobj;
39024 fail:
39025 return NULL;
39026 }
39027
39028
39029 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39030 PyObject *resultobj = 0;
39031 wxMenu *arg1 = (wxMenu *) 0 ;
39032 size_t arg2 ;
39033 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39034 wxMenuItem *result = 0 ;
39035 void *argp1 = 0 ;
39036 int res1 = 0 ;
39037 size_t val2 ;
39038 int ecode2 = 0 ;
39039 int res3 = 0 ;
39040 PyObject * obj0 = 0 ;
39041 PyObject * obj1 = 0 ;
39042 PyObject * obj2 = 0 ;
39043 char * kwnames[] = {
39044 (char *) "self",(char *) "pos",(char *) "item", NULL
39045 };
39046
39047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39049 if (!SWIG_IsOK(res1)) {
39050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39051 }
39052 arg1 = reinterpret_cast< wxMenu * >(argp1);
39053 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39054 if (!SWIG_IsOK(ecode2)) {
39055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39056 }
39057 arg2 = static_cast< size_t >(val2);
39058 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39059 if (!SWIG_IsOK(res3)) {
39060 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39061 }
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39065 wxPyEndAllowThreads(__tstate);
39066 if (PyErr_Occurred()) SWIG_fail;
39067 }
39068 {
39069 resultobj = wxPyMake_wxObject(result, (bool)0);
39070 }
39071 return resultobj;
39072 fail:
39073 return NULL;
39074 }
39075
39076
39077 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39078 PyObject *resultobj = 0;
39079 wxMenu *arg1 = (wxMenu *) 0 ;
39080 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39081 wxMenuItem *result = 0 ;
39082 void *argp1 = 0 ;
39083 int res1 = 0 ;
39084 int res2 = 0 ;
39085 PyObject * obj0 = 0 ;
39086 PyObject * obj1 = 0 ;
39087 char * kwnames[] = {
39088 (char *) "self",(char *) "item", NULL
39089 };
39090
39091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39093 if (!SWIG_IsOK(res1)) {
39094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39095 }
39096 arg1 = reinterpret_cast< wxMenu * >(argp1);
39097 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39098 if (!SWIG_IsOK(res2)) {
39099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39100 }
39101 {
39102 PyThreadState* __tstate = wxPyBeginAllowThreads();
39103 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 {
39108 resultobj = wxPyMake_wxObject(result, (bool)0);
39109 }
39110 return resultobj;
39111 fail:
39112 return NULL;
39113 }
39114
39115
39116 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39117 PyObject *resultobj = 0;
39118 wxMenu *arg1 = (wxMenu *) 0 ;
39119 void *argp1 = 0 ;
39120 int res1 = 0 ;
39121 PyObject *swig_obj[1] ;
39122
39123 if (!args) SWIG_fail;
39124 swig_obj[0] = args;
39125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39126 if (!SWIG_IsOK(res1)) {
39127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39128 }
39129 arg1 = reinterpret_cast< wxMenu * >(argp1);
39130 {
39131 PyThreadState* __tstate = wxPyBeginAllowThreads();
39132 (arg1)->Break();
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 resultobj = SWIG_Py_Void();
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj = 0;
39145 wxMenu *arg1 = (wxMenu *) 0 ;
39146 size_t arg2 ;
39147 int arg3 ;
39148 wxString *arg4 = 0 ;
39149 wxString const &arg5_defvalue = wxPyEmptyString ;
39150 wxString *arg5 = (wxString *) &arg5_defvalue ;
39151 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39152 wxMenuItem *result = 0 ;
39153 void *argp1 = 0 ;
39154 int res1 = 0 ;
39155 size_t val2 ;
39156 int ecode2 = 0 ;
39157 int val3 ;
39158 int ecode3 = 0 ;
39159 bool temp4 = false ;
39160 bool temp5 = false ;
39161 int val6 ;
39162 int ecode6 = 0 ;
39163 PyObject * obj0 = 0 ;
39164 PyObject * obj1 = 0 ;
39165 PyObject * obj2 = 0 ;
39166 PyObject * obj3 = 0 ;
39167 PyObject * obj4 = 0 ;
39168 PyObject * obj5 = 0 ;
39169 char * kwnames[] = {
39170 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39171 };
39172
39173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39175 if (!SWIG_IsOK(res1)) {
39176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39177 }
39178 arg1 = reinterpret_cast< wxMenu * >(argp1);
39179 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39180 if (!SWIG_IsOK(ecode2)) {
39181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39182 }
39183 arg2 = static_cast< size_t >(val2);
39184 ecode3 = SWIG_AsVal_int(obj2, &val3);
39185 if (!SWIG_IsOK(ecode3)) {
39186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39187 }
39188 arg3 = static_cast< int >(val3);
39189 {
39190 arg4 = wxString_in_helper(obj3);
39191 if (arg4 == NULL) SWIG_fail;
39192 temp4 = true;
39193 }
39194 if (obj4) {
39195 {
39196 arg5 = wxString_in_helper(obj4);
39197 if (arg5 == NULL) SWIG_fail;
39198 temp5 = true;
39199 }
39200 }
39201 if (obj5) {
39202 ecode6 = SWIG_AsVal_int(obj5, &val6);
39203 if (!SWIG_IsOK(ecode6)) {
39204 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39205 }
39206 arg6 = static_cast< wxItemKind >(val6);
39207 }
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 {
39215 resultobj = wxPyMake_wxObject(result, (bool)0);
39216 }
39217 {
39218 if (temp4)
39219 delete arg4;
39220 }
39221 {
39222 if (temp5)
39223 delete arg5;
39224 }
39225 return resultobj;
39226 fail:
39227 {
39228 if (temp4)
39229 delete arg4;
39230 }
39231 {
39232 if (temp5)
39233 delete arg5;
39234 }
39235 return NULL;
39236 }
39237
39238
39239 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39240 PyObject *resultobj = 0;
39241 wxMenu *arg1 = (wxMenu *) 0 ;
39242 size_t arg2 ;
39243 wxMenuItem *result = 0 ;
39244 void *argp1 = 0 ;
39245 int res1 = 0 ;
39246 size_t val2 ;
39247 int ecode2 = 0 ;
39248 PyObject * obj0 = 0 ;
39249 PyObject * obj1 = 0 ;
39250 char * kwnames[] = {
39251 (char *) "self",(char *) "pos", NULL
39252 };
39253
39254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39256 if (!SWIG_IsOK(res1)) {
39257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39258 }
39259 arg1 = reinterpret_cast< wxMenu * >(argp1);
39260 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39261 if (!SWIG_IsOK(ecode2)) {
39262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39263 }
39264 arg2 = static_cast< size_t >(val2);
39265 {
39266 PyThreadState* __tstate = wxPyBeginAllowThreads();
39267 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39268 wxPyEndAllowThreads(__tstate);
39269 if (PyErr_Occurred()) SWIG_fail;
39270 }
39271 {
39272 resultobj = wxPyMake_wxObject(result, (bool)0);
39273 }
39274 return resultobj;
39275 fail:
39276 return NULL;
39277 }
39278
39279
39280 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39281 PyObject *resultobj = 0;
39282 wxMenu *arg1 = (wxMenu *) 0 ;
39283 size_t arg2 ;
39284 int arg3 ;
39285 wxString *arg4 = 0 ;
39286 wxString const &arg5_defvalue = wxPyEmptyString ;
39287 wxString *arg5 = (wxString *) &arg5_defvalue ;
39288 wxMenuItem *result = 0 ;
39289 void *argp1 = 0 ;
39290 int res1 = 0 ;
39291 size_t val2 ;
39292 int ecode2 = 0 ;
39293 int val3 ;
39294 int ecode3 = 0 ;
39295 bool temp4 = false ;
39296 bool temp5 = false ;
39297 PyObject * obj0 = 0 ;
39298 PyObject * obj1 = 0 ;
39299 PyObject * obj2 = 0 ;
39300 PyObject * obj3 = 0 ;
39301 PyObject * obj4 = 0 ;
39302 char * kwnames[] = {
39303 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39304 };
39305
39306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39308 if (!SWIG_IsOK(res1)) {
39309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39310 }
39311 arg1 = reinterpret_cast< wxMenu * >(argp1);
39312 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39313 if (!SWIG_IsOK(ecode2)) {
39314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39315 }
39316 arg2 = static_cast< size_t >(val2);
39317 ecode3 = SWIG_AsVal_int(obj2, &val3);
39318 if (!SWIG_IsOK(ecode3)) {
39319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39320 }
39321 arg3 = static_cast< int >(val3);
39322 {
39323 arg4 = wxString_in_helper(obj3);
39324 if (arg4 == NULL) SWIG_fail;
39325 temp4 = true;
39326 }
39327 if (obj4) {
39328 {
39329 arg5 = wxString_in_helper(obj4);
39330 if (arg5 == NULL) SWIG_fail;
39331 temp5 = true;
39332 }
39333 }
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39337 wxPyEndAllowThreads(__tstate);
39338 if (PyErr_Occurred()) SWIG_fail;
39339 }
39340 {
39341 resultobj = wxPyMake_wxObject(result, (bool)0);
39342 }
39343 {
39344 if (temp4)
39345 delete arg4;
39346 }
39347 {
39348 if (temp5)
39349 delete arg5;
39350 }
39351 return resultobj;
39352 fail:
39353 {
39354 if (temp4)
39355 delete arg4;
39356 }
39357 {
39358 if (temp5)
39359 delete arg5;
39360 }
39361 return NULL;
39362 }
39363
39364
39365 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39366 PyObject *resultobj = 0;
39367 wxMenu *arg1 = (wxMenu *) 0 ;
39368 size_t arg2 ;
39369 int arg3 ;
39370 wxString *arg4 = 0 ;
39371 wxString const &arg5_defvalue = wxPyEmptyString ;
39372 wxString *arg5 = (wxString *) &arg5_defvalue ;
39373 wxMenuItem *result = 0 ;
39374 void *argp1 = 0 ;
39375 int res1 = 0 ;
39376 size_t val2 ;
39377 int ecode2 = 0 ;
39378 int val3 ;
39379 int ecode3 = 0 ;
39380 bool temp4 = false ;
39381 bool temp5 = false ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 PyObject * obj2 = 0 ;
39385 PyObject * obj3 = 0 ;
39386 PyObject * obj4 = 0 ;
39387 char * kwnames[] = {
39388 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39389 };
39390
39391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39393 if (!SWIG_IsOK(res1)) {
39394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39395 }
39396 arg1 = reinterpret_cast< wxMenu * >(argp1);
39397 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39398 if (!SWIG_IsOK(ecode2)) {
39399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39400 }
39401 arg2 = static_cast< size_t >(val2);
39402 ecode3 = SWIG_AsVal_int(obj2, &val3);
39403 if (!SWIG_IsOK(ecode3)) {
39404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39405 }
39406 arg3 = static_cast< int >(val3);
39407 {
39408 arg4 = wxString_in_helper(obj3);
39409 if (arg4 == NULL) SWIG_fail;
39410 temp4 = true;
39411 }
39412 if (obj4) {
39413 {
39414 arg5 = wxString_in_helper(obj4);
39415 if (arg5 == NULL) SWIG_fail;
39416 temp5 = true;
39417 }
39418 }
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39422 wxPyEndAllowThreads(__tstate);
39423 if (PyErr_Occurred()) SWIG_fail;
39424 }
39425 {
39426 resultobj = wxPyMake_wxObject(result, (bool)0);
39427 }
39428 {
39429 if (temp4)
39430 delete arg4;
39431 }
39432 {
39433 if (temp5)
39434 delete arg5;
39435 }
39436 return resultobj;
39437 fail:
39438 {
39439 if (temp4)
39440 delete arg4;
39441 }
39442 {
39443 if (temp5)
39444 delete arg5;
39445 }
39446 return NULL;
39447 }
39448
39449
39450 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39451 PyObject *resultobj = 0;
39452 wxMenu *arg1 = (wxMenu *) 0 ;
39453 size_t arg2 ;
39454 int arg3 ;
39455 wxString *arg4 = 0 ;
39456 wxMenu *arg5 = (wxMenu *) 0 ;
39457 wxString const &arg6_defvalue = wxPyEmptyString ;
39458 wxString *arg6 = (wxString *) &arg6_defvalue ;
39459 wxMenuItem *result = 0 ;
39460 void *argp1 = 0 ;
39461 int res1 = 0 ;
39462 size_t val2 ;
39463 int ecode2 = 0 ;
39464 int val3 ;
39465 int ecode3 = 0 ;
39466 bool temp4 = false ;
39467 void *argp5 = 0 ;
39468 int res5 = 0 ;
39469 bool temp6 = false ;
39470 PyObject * obj0 = 0 ;
39471 PyObject * obj1 = 0 ;
39472 PyObject * obj2 = 0 ;
39473 PyObject * obj3 = 0 ;
39474 PyObject * obj4 = 0 ;
39475 PyObject * obj5 = 0 ;
39476 char * kwnames[] = {
39477 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39478 };
39479
39480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39482 if (!SWIG_IsOK(res1)) {
39483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39484 }
39485 arg1 = reinterpret_cast< wxMenu * >(argp1);
39486 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39487 if (!SWIG_IsOK(ecode2)) {
39488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39489 }
39490 arg2 = static_cast< size_t >(val2);
39491 ecode3 = SWIG_AsVal_int(obj2, &val3);
39492 if (!SWIG_IsOK(ecode3)) {
39493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39494 }
39495 arg3 = static_cast< int >(val3);
39496 {
39497 arg4 = wxString_in_helper(obj3);
39498 if (arg4 == NULL) SWIG_fail;
39499 temp4 = true;
39500 }
39501 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39502 if (!SWIG_IsOK(res5)) {
39503 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39504 }
39505 arg5 = reinterpret_cast< wxMenu * >(argp5);
39506 if (obj5) {
39507 {
39508 arg6 = wxString_in_helper(obj5);
39509 if (arg6 == NULL) SWIG_fail;
39510 temp6 = true;
39511 }
39512 }
39513 {
39514 PyThreadState* __tstate = wxPyBeginAllowThreads();
39515 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39516 wxPyEndAllowThreads(__tstate);
39517 if (PyErr_Occurred()) SWIG_fail;
39518 }
39519 {
39520 resultobj = wxPyMake_wxObject(result, (bool)0);
39521 }
39522 {
39523 if (temp4)
39524 delete arg4;
39525 }
39526 {
39527 if (temp6)
39528 delete arg6;
39529 }
39530 return resultobj;
39531 fail:
39532 {
39533 if (temp4)
39534 delete arg4;
39535 }
39536 {
39537 if (temp6)
39538 delete arg6;
39539 }
39540 return NULL;
39541 }
39542
39543
39544 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39545 PyObject *resultobj = 0;
39546 wxMenu *arg1 = (wxMenu *) 0 ;
39547 int arg2 ;
39548 wxString *arg3 = 0 ;
39549 wxString const &arg4_defvalue = wxPyEmptyString ;
39550 wxString *arg4 = (wxString *) &arg4_defvalue ;
39551 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39552 wxMenuItem *result = 0 ;
39553 void *argp1 = 0 ;
39554 int res1 = 0 ;
39555 int val2 ;
39556 int ecode2 = 0 ;
39557 bool temp3 = false ;
39558 bool temp4 = false ;
39559 int val5 ;
39560 int ecode5 = 0 ;
39561 PyObject * obj0 = 0 ;
39562 PyObject * obj1 = 0 ;
39563 PyObject * obj2 = 0 ;
39564 PyObject * obj3 = 0 ;
39565 PyObject * obj4 = 0 ;
39566 char * kwnames[] = {
39567 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39568 };
39569
39570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39572 if (!SWIG_IsOK(res1)) {
39573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39574 }
39575 arg1 = reinterpret_cast< wxMenu * >(argp1);
39576 ecode2 = SWIG_AsVal_int(obj1, &val2);
39577 if (!SWIG_IsOK(ecode2)) {
39578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39579 }
39580 arg2 = static_cast< int >(val2);
39581 {
39582 arg3 = wxString_in_helper(obj2);
39583 if (arg3 == NULL) SWIG_fail;
39584 temp3 = true;
39585 }
39586 if (obj3) {
39587 {
39588 arg4 = wxString_in_helper(obj3);
39589 if (arg4 == NULL) SWIG_fail;
39590 temp4 = true;
39591 }
39592 }
39593 if (obj4) {
39594 ecode5 = SWIG_AsVal_int(obj4, &val5);
39595 if (!SWIG_IsOK(ecode5)) {
39596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39597 }
39598 arg5 = static_cast< wxItemKind >(val5);
39599 }
39600 {
39601 PyThreadState* __tstate = wxPyBeginAllowThreads();
39602 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39603 wxPyEndAllowThreads(__tstate);
39604 if (PyErr_Occurred()) SWIG_fail;
39605 }
39606 {
39607 resultobj = wxPyMake_wxObject(result, (bool)0);
39608 }
39609 {
39610 if (temp3)
39611 delete arg3;
39612 }
39613 {
39614 if (temp4)
39615 delete arg4;
39616 }
39617 return resultobj;
39618 fail:
39619 {
39620 if (temp3)
39621 delete arg3;
39622 }
39623 {
39624 if (temp4)
39625 delete arg4;
39626 }
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39632 PyObject *resultobj = 0;
39633 wxMenu *arg1 = (wxMenu *) 0 ;
39634 wxMenuItem *result = 0 ;
39635 void *argp1 = 0 ;
39636 int res1 = 0 ;
39637 PyObject *swig_obj[1] ;
39638
39639 if (!args) SWIG_fail;
39640 swig_obj[0] = args;
39641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39642 if (!SWIG_IsOK(res1)) {
39643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39644 }
39645 arg1 = reinterpret_cast< wxMenu * >(argp1);
39646 {
39647 PyThreadState* __tstate = wxPyBeginAllowThreads();
39648 result = (wxMenuItem *)(arg1)->PrependSeparator();
39649 wxPyEndAllowThreads(__tstate);
39650 if (PyErr_Occurred()) SWIG_fail;
39651 }
39652 {
39653 resultobj = wxPyMake_wxObject(result, (bool)0);
39654 }
39655 return resultobj;
39656 fail:
39657 return NULL;
39658 }
39659
39660
39661 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39662 PyObject *resultobj = 0;
39663 wxMenu *arg1 = (wxMenu *) 0 ;
39664 int arg2 ;
39665 wxString *arg3 = 0 ;
39666 wxString const &arg4_defvalue = wxPyEmptyString ;
39667 wxString *arg4 = (wxString *) &arg4_defvalue ;
39668 wxMenuItem *result = 0 ;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671 int val2 ;
39672 int ecode2 = 0 ;
39673 bool temp3 = false ;
39674 bool temp4 = false ;
39675 PyObject * obj0 = 0 ;
39676 PyObject * obj1 = 0 ;
39677 PyObject * obj2 = 0 ;
39678 PyObject * obj3 = 0 ;
39679 char * kwnames[] = {
39680 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39681 };
39682
39683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39685 if (!SWIG_IsOK(res1)) {
39686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39687 }
39688 arg1 = reinterpret_cast< wxMenu * >(argp1);
39689 ecode2 = SWIG_AsVal_int(obj1, &val2);
39690 if (!SWIG_IsOK(ecode2)) {
39691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39692 }
39693 arg2 = static_cast< int >(val2);
39694 {
39695 arg3 = wxString_in_helper(obj2);
39696 if (arg3 == NULL) SWIG_fail;
39697 temp3 = true;
39698 }
39699 if (obj3) {
39700 {
39701 arg4 = wxString_in_helper(obj3);
39702 if (arg4 == NULL) SWIG_fail;
39703 temp4 = true;
39704 }
39705 }
39706 {
39707 PyThreadState* __tstate = wxPyBeginAllowThreads();
39708 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39709 wxPyEndAllowThreads(__tstate);
39710 if (PyErr_Occurred()) SWIG_fail;
39711 }
39712 {
39713 resultobj = wxPyMake_wxObject(result, (bool)0);
39714 }
39715 {
39716 if (temp3)
39717 delete arg3;
39718 }
39719 {
39720 if (temp4)
39721 delete arg4;
39722 }
39723 return resultobj;
39724 fail:
39725 {
39726 if (temp3)
39727 delete arg3;
39728 }
39729 {
39730 if (temp4)
39731 delete arg4;
39732 }
39733 return NULL;
39734 }
39735
39736
39737 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj = 0;
39739 wxMenu *arg1 = (wxMenu *) 0 ;
39740 int arg2 ;
39741 wxString *arg3 = 0 ;
39742 wxString const &arg4_defvalue = wxPyEmptyString ;
39743 wxString *arg4 = (wxString *) &arg4_defvalue ;
39744 wxMenuItem *result = 0 ;
39745 void *argp1 = 0 ;
39746 int res1 = 0 ;
39747 int val2 ;
39748 int ecode2 = 0 ;
39749 bool temp3 = false ;
39750 bool temp4 = false ;
39751 PyObject * obj0 = 0 ;
39752 PyObject * obj1 = 0 ;
39753 PyObject * obj2 = 0 ;
39754 PyObject * obj3 = 0 ;
39755 char * kwnames[] = {
39756 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39757 };
39758
39759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39761 if (!SWIG_IsOK(res1)) {
39762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39763 }
39764 arg1 = reinterpret_cast< wxMenu * >(argp1);
39765 ecode2 = SWIG_AsVal_int(obj1, &val2);
39766 if (!SWIG_IsOK(ecode2)) {
39767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39768 }
39769 arg2 = static_cast< int >(val2);
39770 {
39771 arg3 = wxString_in_helper(obj2);
39772 if (arg3 == NULL) SWIG_fail;
39773 temp3 = true;
39774 }
39775 if (obj3) {
39776 {
39777 arg4 = wxString_in_helper(obj3);
39778 if (arg4 == NULL) SWIG_fail;
39779 temp4 = true;
39780 }
39781 }
39782 {
39783 PyThreadState* __tstate = wxPyBeginAllowThreads();
39784 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39785 wxPyEndAllowThreads(__tstate);
39786 if (PyErr_Occurred()) SWIG_fail;
39787 }
39788 {
39789 resultobj = wxPyMake_wxObject(result, (bool)0);
39790 }
39791 {
39792 if (temp3)
39793 delete arg3;
39794 }
39795 {
39796 if (temp4)
39797 delete arg4;
39798 }
39799 return resultobj;
39800 fail:
39801 {
39802 if (temp3)
39803 delete arg3;
39804 }
39805 {
39806 if (temp4)
39807 delete arg4;
39808 }
39809 return NULL;
39810 }
39811
39812
39813 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39814 PyObject *resultobj = 0;
39815 wxMenu *arg1 = (wxMenu *) 0 ;
39816 int arg2 ;
39817 wxString *arg3 = 0 ;
39818 wxMenu *arg4 = (wxMenu *) 0 ;
39819 wxString const &arg5_defvalue = wxPyEmptyString ;
39820 wxString *arg5 = (wxString *) &arg5_defvalue ;
39821 wxMenuItem *result = 0 ;
39822 void *argp1 = 0 ;
39823 int res1 = 0 ;
39824 int val2 ;
39825 int ecode2 = 0 ;
39826 bool temp3 = false ;
39827 void *argp4 = 0 ;
39828 int res4 = 0 ;
39829 bool temp5 = false ;
39830 PyObject * obj0 = 0 ;
39831 PyObject * obj1 = 0 ;
39832 PyObject * obj2 = 0 ;
39833 PyObject * obj3 = 0 ;
39834 PyObject * obj4 = 0 ;
39835 char * kwnames[] = {
39836 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39837 };
39838
39839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39841 if (!SWIG_IsOK(res1)) {
39842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39843 }
39844 arg1 = reinterpret_cast< wxMenu * >(argp1);
39845 ecode2 = SWIG_AsVal_int(obj1, &val2);
39846 if (!SWIG_IsOK(ecode2)) {
39847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39848 }
39849 arg2 = static_cast< int >(val2);
39850 {
39851 arg3 = wxString_in_helper(obj2);
39852 if (arg3 == NULL) SWIG_fail;
39853 temp3 = true;
39854 }
39855 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39856 if (!SWIG_IsOK(res4)) {
39857 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39858 }
39859 arg4 = reinterpret_cast< wxMenu * >(argp4);
39860 if (obj4) {
39861 {
39862 arg5 = wxString_in_helper(obj4);
39863 if (arg5 == NULL) SWIG_fail;
39864 temp5 = true;
39865 }
39866 }
39867 {
39868 PyThreadState* __tstate = wxPyBeginAllowThreads();
39869 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 {
39874 resultobj = wxPyMake_wxObject(result, (bool)0);
39875 }
39876 {
39877 if (temp3)
39878 delete arg3;
39879 }
39880 {
39881 if (temp5)
39882 delete arg5;
39883 }
39884 return resultobj;
39885 fail:
39886 {
39887 if (temp3)
39888 delete arg3;
39889 }
39890 {
39891 if (temp5)
39892 delete arg5;
39893 }
39894 return NULL;
39895 }
39896
39897
39898 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj = 0;
39900 wxMenu *arg1 = (wxMenu *) 0 ;
39901 int arg2 ;
39902 wxMenuItem *result = 0 ;
39903 void *argp1 = 0 ;
39904 int res1 = 0 ;
39905 int val2 ;
39906 int ecode2 = 0 ;
39907 PyObject * obj0 = 0 ;
39908 PyObject * obj1 = 0 ;
39909 char * kwnames[] = {
39910 (char *) "self",(char *) "id", NULL
39911 };
39912
39913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39915 if (!SWIG_IsOK(res1)) {
39916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39917 }
39918 arg1 = reinterpret_cast< wxMenu * >(argp1);
39919 ecode2 = SWIG_AsVal_int(obj1, &val2);
39920 if (!SWIG_IsOK(ecode2)) {
39921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39922 }
39923 arg2 = static_cast< int >(val2);
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (wxMenuItem *)(arg1)->Remove(arg2);
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 {
39931 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39932 }
39933 return resultobj;
39934 fail:
39935 return NULL;
39936 }
39937
39938
39939 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39940 PyObject *resultobj = 0;
39941 wxMenu *arg1 = (wxMenu *) 0 ;
39942 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39943 wxMenuItem *result = 0 ;
39944 void *argp1 = 0 ;
39945 int res1 = 0 ;
39946 void *argp2 = 0 ;
39947 int res2 = 0 ;
39948 PyObject * obj0 = 0 ;
39949 PyObject * obj1 = 0 ;
39950 char * kwnames[] = {
39951 (char *) "self",(char *) "item", NULL
39952 };
39953
39954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",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_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39958 }
39959 arg1 = reinterpret_cast< wxMenu * >(argp1);
39960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39961 if (!SWIG_IsOK(res2)) {
39962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39963 }
39964 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 result = (wxMenuItem *)(arg1)->Remove(arg2);
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 {
39972 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39973 }
39974 return resultobj;
39975 fail:
39976 return NULL;
39977 }
39978
39979
39980 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39981 PyObject *resultobj = 0;
39982 wxMenu *arg1 = (wxMenu *) 0 ;
39983 int arg2 ;
39984 bool result;
39985 void *argp1 = 0 ;
39986 int res1 = 0 ;
39987 int val2 ;
39988 int ecode2 = 0 ;
39989 PyObject * obj0 = 0 ;
39990 PyObject * obj1 = 0 ;
39991 char * kwnames[] = {
39992 (char *) "self",(char *) "id", NULL
39993 };
39994
39995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39997 if (!SWIG_IsOK(res1)) {
39998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39999 }
40000 arg1 = reinterpret_cast< wxMenu * >(argp1);
40001 ecode2 = SWIG_AsVal_int(obj1, &val2);
40002 if (!SWIG_IsOK(ecode2)) {
40003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40004 }
40005 arg2 = static_cast< int >(val2);
40006 {
40007 PyThreadState* __tstate = wxPyBeginAllowThreads();
40008 result = (bool)(arg1)->Delete(arg2);
40009 wxPyEndAllowThreads(__tstate);
40010 if (PyErr_Occurred()) SWIG_fail;
40011 }
40012 {
40013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40014 }
40015 return resultobj;
40016 fail:
40017 return NULL;
40018 }
40019
40020
40021 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40022 PyObject *resultobj = 0;
40023 wxMenu *arg1 = (wxMenu *) 0 ;
40024 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40025 bool result;
40026 void *argp1 = 0 ;
40027 int res1 = 0 ;
40028 void *argp2 = 0 ;
40029 int res2 = 0 ;
40030 PyObject * obj0 = 0 ;
40031 PyObject * obj1 = 0 ;
40032 char * kwnames[] = {
40033 (char *) "self",(char *) "item", NULL
40034 };
40035
40036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40038 if (!SWIG_IsOK(res1)) {
40039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40040 }
40041 arg1 = reinterpret_cast< wxMenu * >(argp1);
40042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40043 if (!SWIG_IsOK(res2)) {
40044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40045 }
40046 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40047 {
40048 PyThreadState* __tstate = wxPyBeginAllowThreads();
40049 result = (bool)(arg1)->Delete(arg2);
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 {
40054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40055 }
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40063 PyObject *resultobj = 0;
40064 wxMenu *arg1 = (wxMenu *) 0 ;
40065 void *argp1 = 0 ;
40066 int res1 = 0 ;
40067 PyObject *swig_obj[1] ;
40068
40069 if (!args) SWIG_fail;
40070 swig_obj[0] = args;
40071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40072 if (!SWIG_IsOK(res1)) {
40073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40074 }
40075 arg1 = reinterpret_cast< wxMenu * >(argp1);
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 wxMenu_Destroy(arg1);
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 resultobj = SWIG_Py_Void();
40083 return resultobj;
40084 fail:
40085 return NULL;
40086 }
40087
40088
40089 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40090 PyObject *resultobj = 0;
40091 wxMenu *arg1 = (wxMenu *) 0 ;
40092 int arg2 ;
40093 bool result;
40094 void *argp1 = 0 ;
40095 int res1 = 0 ;
40096 int val2 ;
40097 int ecode2 = 0 ;
40098 PyObject * obj0 = 0 ;
40099 PyObject * obj1 = 0 ;
40100 char * kwnames[] = {
40101 (char *) "self",(char *) "id", NULL
40102 };
40103
40104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40106 if (!SWIG_IsOK(res1)) {
40107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40108 }
40109 arg1 = reinterpret_cast< wxMenu * >(argp1);
40110 ecode2 = SWIG_AsVal_int(obj1, &val2);
40111 if (!SWIG_IsOK(ecode2)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40113 }
40114 arg2 = static_cast< int >(val2);
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 result = (bool)(arg1)->Destroy(arg2);
40118 wxPyEndAllowThreads(__tstate);
40119 if (PyErr_Occurred()) SWIG_fail;
40120 }
40121 {
40122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40123 }
40124 return resultobj;
40125 fail:
40126 return NULL;
40127 }
40128
40129
40130 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40131 PyObject *resultobj = 0;
40132 wxMenu *arg1 = (wxMenu *) 0 ;
40133 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40134 bool result;
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 *) "item", NULL
40143 };
40144
40145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",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_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40149 }
40150 arg1 = reinterpret_cast< wxMenu * >(argp1);
40151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40152 if (!SWIG_IsOK(res2)) {
40153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40154 }
40155 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (bool)(arg1)->Destroy(arg2);
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 {
40163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40164 }
40165 return resultobj;
40166 fail:
40167 return NULL;
40168 }
40169
40170
40171 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40172 PyObject *resultobj = 0;
40173 wxMenu *arg1 = (wxMenu *) 0 ;
40174 size_t result;
40175 void *argp1 = 0 ;
40176 int res1 = 0 ;
40177 PyObject *swig_obj[1] ;
40178
40179 if (!args) SWIG_fail;
40180 swig_obj[0] = args;
40181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40182 if (!SWIG_IsOK(res1)) {
40183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40184 }
40185 arg1 = reinterpret_cast< wxMenu * >(argp1);
40186 {
40187 PyThreadState* __tstate = wxPyBeginAllowThreads();
40188 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40189 wxPyEndAllowThreads(__tstate);
40190 if (PyErr_Occurred()) SWIG_fail;
40191 }
40192 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40193 return resultobj;
40194 fail:
40195 return NULL;
40196 }
40197
40198
40199 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40200 PyObject *resultobj = 0;
40201 wxMenu *arg1 = (wxMenu *) 0 ;
40202 PyObject *result = 0 ;
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_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40212 }
40213 arg1 = reinterpret_cast< wxMenu * >(argp1);
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 resultobj = result;
40221 return resultobj;
40222 fail:
40223 return NULL;
40224 }
40225
40226
40227 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40228 PyObject *resultobj = 0;
40229 wxMenu *arg1 = (wxMenu *) 0 ;
40230 wxString *arg2 = 0 ;
40231 int result;
40232 void *argp1 = 0 ;
40233 int res1 = 0 ;
40234 bool temp2 = false ;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 char * kwnames[] = {
40238 (char *) "self",(char *) "item", NULL
40239 };
40240
40241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",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_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40245 }
40246 arg1 = reinterpret_cast< wxMenu * >(argp1);
40247 {
40248 arg2 = wxString_in_helper(obj1);
40249 if (arg2 == NULL) SWIG_fail;
40250 temp2 = true;
40251 }
40252 {
40253 PyThreadState* __tstate = wxPyBeginAllowThreads();
40254 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40255 wxPyEndAllowThreads(__tstate);
40256 if (PyErr_Occurred()) SWIG_fail;
40257 }
40258 resultobj = SWIG_From_int(static_cast< int >(result));
40259 {
40260 if (temp2)
40261 delete arg2;
40262 }
40263 return resultobj;
40264 fail:
40265 {
40266 if (temp2)
40267 delete arg2;
40268 }
40269 return NULL;
40270 }
40271
40272
40273 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = 0;
40275 wxMenu *arg1 = (wxMenu *) 0 ;
40276 int arg2 ;
40277 wxMenuItem *result = 0 ;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 int val2 ;
40281 int ecode2 = 0 ;
40282 PyObject * obj0 = 0 ;
40283 PyObject * obj1 = 0 ;
40284 char * kwnames[] = {
40285 (char *) "self",(char *) "id", NULL
40286 };
40287
40288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40292 }
40293 arg1 = reinterpret_cast< wxMenu * >(argp1);
40294 ecode2 = SWIG_AsVal_int(obj1, &val2);
40295 if (!SWIG_IsOK(ecode2)) {
40296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40297 }
40298 arg2 = static_cast< int >(val2);
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 {
40306 resultobj = wxPyMake_wxObject(result, (bool)0);
40307 }
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj = 0;
40316 wxMenu *arg1 = (wxMenu *) 0 ;
40317 size_t arg2 ;
40318 wxMenuItem *result = 0 ;
40319 void *argp1 = 0 ;
40320 int res1 = 0 ;
40321 size_t val2 ;
40322 int ecode2 = 0 ;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 char * kwnames[] = {
40326 (char *) "self",(char *) "position", NULL
40327 };
40328
40329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40331 if (!SWIG_IsOK(res1)) {
40332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40333 }
40334 arg1 = reinterpret_cast< wxMenu * >(argp1);
40335 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40336 if (!SWIG_IsOK(ecode2)) {
40337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40338 }
40339 arg2 = static_cast< size_t >(val2);
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 {
40347 resultobj = wxPyMake_wxObject(result, (bool)0);
40348 }
40349 return resultobj;
40350 fail:
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 bool arg3 ;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 bool val3 ;
40365 int ecode3 = 0 ;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 PyObject * obj2 = 0 ;
40369 char * kwnames[] = {
40370 (char *) "self",(char *) "id",(char *) "enable", NULL
40371 };
40372
40373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40375 if (!SWIG_IsOK(res1)) {
40376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40377 }
40378 arg1 = reinterpret_cast< wxMenu * >(argp1);
40379 ecode2 = SWIG_AsVal_int(obj1, &val2);
40380 if (!SWIG_IsOK(ecode2)) {
40381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40382 }
40383 arg2 = static_cast< int >(val2);
40384 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40385 if (!SWIG_IsOK(ecode3)) {
40386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40387 }
40388 arg3 = static_cast< bool >(val3);
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 (arg1)->Enable(arg2,arg3);
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = SWIG_Py_Void();
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40403 PyObject *resultobj = 0;
40404 wxMenu *arg1 = (wxMenu *) 0 ;
40405 int arg2 ;
40406 bool result;
40407 void *argp1 = 0 ;
40408 int res1 = 0 ;
40409 int val2 ;
40410 int ecode2 = 0 ;
40411 PyObject * obj0 = 0 ;
40412 PyObject * obj1 = 0 ;
40413 char * kwnames[] = {
40414 (char *) "self",(char *) "id", NULL
40415 };
40416
40417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40421 }
40422 arg1 = reinterpret_cast< wxMenu * >(argp1);
40423 ecode2 = SWIG_AsVal_int(obj1, &val2);
40424 if (!SWIG_IsOK(ecode2)) {
40425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40426 }
40427 arg2 = static_cast< int >(val2);
40428 {
40429 PyThreadState* __tstate = wxPyBeginAllowThreads();
40430 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40431 wxPyEndAllowThreads(__tstate);
40432 if (PyErr_Occurred()) SWIG_fail;
40433 }
40434 {
40435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40436 }
40437 return resultobj;
40438 fail:
40439 return NULL;
40440 }
40441
40442
40443 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40444 PyObject *resultobj = 0;
40445 wxMenu *arg1 = (wxMenu *) 0 ;
40446 int arg2 ;
40447 bool arg3 ;
40448 void *argp1 = 0 ;
40449 int res1 = 0 ;
40450 int val2 ;
40451 int ecode2 = 0 ;
40452 bool val3 ;
40453 int ecode3 = 0 ;
40454 PyObject * obj0 = 0 ;
40455 PyObject * obj1 = 0 ;
40456 PyObject * obj2 = 0 ;
40457 char * kwnames[] = {
40458 (char *) "self",(char *) "id",(char *) "check", NULL
40459 };
40460
40461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40463 if (!SWIG_IsOK(res1)) {
40464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40465 }
40466 arg1 = reinterpret_cast< wxMenu * >(argp1);
40467 ecode2 = SWIG_AsVal_int(obj1, &val2);
40468 if (!SWIG_IsOK(ecode2)) {
40469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40470 }
40471 arg2 = static_cast< int >(val2);
40472 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40473 if (!SWIG_IsOK(ecode3)) {
40474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40475 }
40476 arg3 = static_cast< bool >(val3);
40477 {
40478 PyThreadState* __tstate = wxPyBeginAllowThreads();
40479 (arg1)->Check(arg2,arg3);
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 resultobj = SWIG_Py_Void();
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40491 PyObject *resultobj = 0;
40492 wxMenu *arg1 = (wxMenu *) 0 ;
40493 int arg2 ;
40494 bool result;
40495 void *argp1 = 0 ;
40496 int res1 = 0 ;
40497 int val2 ;
40498 int ecode2 = 0 ;
40499 PyObject * obj0 = 0 ;
40500 PyObject * obj1 = 0 ;
40501 char * kwnames[] = {
40502 (char *) "self",(char *) "id", NULL
40503 };
40504
40505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40507 if (!SWIG_IsOK(res1)) {
40508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40509 }
40510 arg1 = reinterpret_cast< wxMenu * >(argp1);
40511 ecode2 = SWIG_AsVal_int(obj1, &val2);
40512 if (!SWIG_IsOK(ecode2)) {
40513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40514 }
40515 arg2 = static_cast< int >(val2);
40516 {
40517 PyThreadState* __tstate = wxPyBeginAllowThreads();
40518 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40519 wxPyEndAllowThreads(__tstate);
40520 if (PyErr_Occurred()) SWIG_fail;
40521 }
40522 {
40523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40524 }
40525 return resultobj;
40526 fail:
40527 return NULL;
40528 }
40529
40530
40531 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40532 PyObject *resultobj = 0;
40533 wxMenu *arg1 = (wxMenu *) 0 ;
40534 int arg2 ;
40535 wxString *arg3 = 0 ;
40536 void *argp1 = 0 ;
40537 int res1 = 0 ;
40538 int val2 ;
40539 int ecode2 = 0 ;
40540 bool temp3 = false ;
40541 PyObject * obj0 = 0 ;
40542 PyObject * obj1 = 0 ;
40543 PyObject * obj2 = 0 ;
40544 char * kwnames[] = {
40545 (char *) "self",(char *) "id",(char *) "label", NULL
40546 };
40547
40548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40550 if (!SWIG_IsOK(res1)) {
40551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 ecode2 = SWIG_AsVal_int(obj1, &val2);
40555 if (!SWIG_IsOK(ecode2)) {
40556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40557 }
40558 arg2 = static_cast< int >(val2);
40559 {
40560 arg3 = wxString_in_helper(obj2);
40561 if (arg3 == NULL) SWIG_fail;
40562 temp3 = true;
40563 }
40564 {
40565 PyThreadState* __tstate = wxPyBeginAllowThreads();
40566 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40567 wxPyEndAllowThreads(__tstate);
40568 if (PyErr_Occurred()) SWIG_fail;
40569 }
40570 resultobj = SWIG_Py_Void();
40571 {
40572 if (temp3)
40573 delete arg3;
40574 }
40575 return resultobj;
40576 fail:
40577 {
40578 if (temp3)
40579 delete arg3;
40580 }
40581 return NULL;
40582 }
40583
40584
40585 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj = 0;
40587 wxMenu *arg1 = (wxMenu *) 0 ;
40588 int arg2 ;
40589 wxString result;
40590 void *argp1 = 0 ;
40591 int res1 = 0 ;
40592 int val2 ;
40593 int ecode2 = 0 ;
40594 PyObject * obj0 = 0 ;
40595 PyObject * obj1 = 0 ;
40596 char * kwnames[] = {
40597 (char *) "self",(char *) "id", NULL
40598 };
40599
40600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40602 if (!SWIG_IsOK(res1)) {
40603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40604 }
40605 arg1 = reinterpret_cast< wxMenu * >(argp1);
40606 ecode2 = SWIG_AsVal_int(obj1, &val2);
40607 if (!SWIG_IsOK(ecode2)) {
40608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40609 }
40610 arg2 = static_cast< int >(val2);
40611 {
40612 PyThreadState* __tstate = wxPyBeginAllowThreads();
40613 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40614 wxPyEndAllowThreads(__tstate);
40615 if (PyErr_Occurred()) SWIG_fail;
40616 }
40617 {
40618 #if wxUSE_UNICODE
40619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40620 #else
40621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40622 #endif
40623 }
40624 return resultobj;
40625 fail:
40626 return NULL;
40627 }
40628
40629
40630 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40631 PyObject *resultobj = 0;
40632 wxMenu *arg1 = (wxMenu *) 0 ;
40633 int arg2 ;
40634 wxString *arg3 = 0 ;
40635 void *argp1 = 0 ;
40636 int res1 = 0 ;
40637 int val2 ;
40638 int ecode2 = 0 ;
40639 bool temp3 = false ;
40640 PyObject * obj0 = 0 ;
40641 PyObject * obj1 = 0 ;
40642 PyObject * obj2 = 0 ;
40643 char * kwnames[] = {
40644 (char *) "self",(char *) "id",(char *) "helpString", NULL
40645 };
40646
40647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40649 if (!SWIG_IsOK(res1)) {
40650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40651 }
40652 arg1 = reinterpret_cast< wxMenu * >(argp1);
40653 ecode2 = SWIG_AsVal_int(obj1, &val2);
40654 if (!SWIG_IsOK(ecode2)) {
40655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40656 }
40657 arg2 = static_cast< int >(val2);
40658 {
40659 arg3 = wxString_in_helper(obj2);
40660 if (arg3 == NULL) SWIG_fail;
40661 temp3 = true;
40662 }
40663 {
40664 PyThreadState* __tstate = wxPyBeginAllowThreads();
40665 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40666 wxPyEndAllowThreads(__tstate);
40667 if (PyErr_Occurred()) SWIG_fail;
40668 }
40669 resultobj = SWIG_Py_Void();
40670 {
40671 if (temp3)
40672 delete arg3;
40673 }
40674 return resultobj;
40675 fail:
40676 {
40677 if (temp3)
40678 delete arg3;
40679 }
40680 return NULL;
40681 }
40682
40683
40684 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40685 PyObject *resultobj = 0;
40686 wxMenu *arg1 = (wxMenu *) 0 ;
40687 int arg2 ;
40688 wxString result;
40689 void *argp1 = 0 ;
40690 int res1 = 0 ;
40691 int val2 ;
40692 int ecode2 = 0 ;
40693 PyObject * obj0 = 0 ;
40694 PyObject * obj1 = 0 ;
40695 char * kwnames[] = {
40696 (char *) "self",(char *) "id", NULL
40697 };
40698
40699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40701 if (!SWIG_IsOK(res1)) {
40702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40703 }
40704 arg1 = reinterpret_cast< wxMenu * >(argp1);
40705 ecode2 = SWIG_AsVal_int(obj1, &val2);
40706 if (!SWIG_IsOK(ecode2)) {
40707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40708 }
40709 arg2 = static_cast< int >(val2);
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 {
40717 #if wxUSE_UNICODE
40718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40719 #else
40720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40721 #endif
40722 }
40723 return resultobj;
40724 fail:
40725 return NULL;
40726 }
40727
40728
40729 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40730 PyObject *resultobj = 0;
40731 wxMenu *arg1 = (wxMenu *) 0 ;
40732 wxString *arg2 = 0 ;
40733 void *argp1 = 0 ;
40734 int res1 = 0 ;
40735 bool temp2 = false ;
40736 PyObject * obj0 = 0 ;
40737 PyObject * obj1 = 0 ;
40738 char * kwnames[] = {
40739 (char *) "self",(char *) "title", NULL
40740 };
40741
40742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40744 if (!SWIG_IsOK(res1)) {
40745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40746 }
40747 arg1 = reinterpret_cast< wxMenu * >(argp1);
40748 {
40749 arg2 = wxString_in_helper(obj1);
40750 if (arg2 == NULL) SWIG_fail;
40751 temp2 = true;
40752 }
40753 {
40754 PyThreadState* __tstate = wxPyBeginAllowThreads();
40755 (arg1)->SetTitle((wxString const &)*arg2);
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 resultobj = SWIG_Py_Void();
40760 {
40761 if (temp2)
40762 delete arg2;
40763 }
40764 return resultobj;
40765 fail:
40766 {
40767 if (temp2)
40768 delete arg2;
40769 }
40770 return NULL;
40771 }
40772
40773
40774 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40775 PyObject *resultobj = 0;
40776 wxMenu *arg1 = (wxMenu *) 0 ;
40777 wxString result;
40778 void *argp1 = 0 ;
40779 int res1 = 0 ;
40780 PyObject *swig_obj[1] ;
40781
40782 if (!args) SWIG_fail;
40783 swig_obj[0] = args;
40784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40785 if (!SWIG_IsOK(res1)) {
40786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40787 }
40788 arg1 = reinterpret_cast< wxMenu * >(argp1);
40789 {
40790 PyThreadState* __tstate = wxPyBeginAllowThreads();
40791 result = ((wxMenu const *)arg1)->GetTitle();
40792 wxPyEndAllowThreads(__tstate);
40793 if (PyErr_Occurred()) SWIG_fail;
40794 }
40795 {
40796 #if wxUSE_UNICODE
40797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40798 #else
40799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40800 #endif
40801 }
40802 return resultobj;
40803 fail:
40804 return NULL;
40805 }
40806
40807
40808 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40809 PyObject *resultobj = 0;
40810 wxMenu *arg1 = (wxMenu *) 0 ;
40811 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40812 void *argp1 = 0 ;
40813 int res1 = 0 ;
40814 void *argp2 = 0 ;
40815 int res2 = 0 ;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 char * kwnames[] = {
40819 (char *) "self",(char *) "handler", NULL
40820 };
40821
40822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40824 if (!SWIG_IsOK(res1)) {
40825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40826 }
40827 arg1 = reinterpret_cast< wxMenu * >(argp1);
40828 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40829 if (!SWIG_IsOK(res2)) {
40830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40831 }
40832 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 (arg1)->SetEventHandler(arg2);
40836 wxPyEndAllowThreads(__tstate);
40837 if (PyErr_Occurred()) SWIG_fail;
40838 }
40839 resultobj = SWIG_Py_Void();
40840 return resultobj;
40841 fail:
40842 return NULL;
40843 }
40844
40845
40846 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40847 PyObject *resultobj = 0;
40848 wxMenu *arg1 = (wxMenu *) 0 ;
40849 wxEvtHandler *result = 0 ;
40850 void *argp1 = 0 ;
40851 int res1 = 0 ;
40852 PyObject *swig_obj[1] ;
40853
40854 if (!args) SWIG_fail;
40855 swig_obj[0] = args;
40856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40857 if (!SWIG_IsOK(res1)) {
40858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40859 }
40860 arg1 = reinterpret_cast< wxMenu * >(argp1);
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40864 wxPyEndAllowThreads(__tstate);
40865 if (PyErr_Occurred()) SWIG_fail;
40866 }
40867 {
40868 resultobj = wxPyMake_wxObject(result, 0);
40869 }
40870 return resultobj;
40871 fail:
40872 return NULL;
40873 }
40874
40875
40876 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40877 PyObject *resultobj = 0;
40878 wxMenu *arg1 = (wxMenu *) 0 ;
40879 wxWindow *arg2 = (wxWindow *) 0 ;
40880 void *argp1 = 0 ;
40881 int res1 = 0 ;
40882 void *argp2 = 0 ;
40883 int res2 = 0 ;
40884 PyObject * obj0 = 0 ;
40885 PyObject * obj1 = 0 ;
40886 char * kwnames[] = {
40887 (char *) "self",(char *) "win", NULL
40888 };
40889
40890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40892 if (!SWIG_IsOK(res1)) {
40893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40894 }
40895 arg1 = reinterpret_cast< wxMenu * >(argp1);
40896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40897 if (!SWIG_IsOK(res2)) {
40898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40899 }
40900 arg2 = reinterpret_cast< wxWindow * >(argp2);
40901 {
40902 PyThreadState* __tstate = wxPyBeginAllowThreads();
40903 (arg1)->SetInvokingWindow(arg2);
40904 wxPyEndAllowThreads(__tstate);
40905 if (PyErr_Occurred()) SWIG_fail;
40906 }
40907 resultobj = SWIG_Py_Void();
40908 return resultobj;
40909 fail:
40910 return NULL;
40911 }
40912
40913
40914 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40915 PyObject *resultobj = 0;
40916 wxMenu *arg1 = (wxMenu *) 0 ;
40917 wxWindow *result = 0 ;
40918 void *argp1 = 0 ;
40919 int res1 = 0 ;
40920 PyObject *swig_obj[1] ;
40921
40922 if (!args) SWIG_fail;
40923 swig_obj[0] = args;
40924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40925 if (!SWIG_IsOK(res1)) {
40926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40927 }
40928 arg1 = reinterpret_cast< wxMenu * >(argp1);
40929 {
40930 PyThreadState* __tstate = wxPyBeginAllowThreads();
40931 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40932 wxPyEndAllowThreads(__tstate);
40933 if (PyErr_Occurred()) SWIG_fail;
40934 }
40935 {
40936 resultobj = wxPyMake_wxObject(result, 0);
40937 }
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40945 PyObject *resultobj = 0;
40946 wxMenu *arg1 = (wxMenu *) 0 ;
40947 long result;
40948 void *argp1 = 0 ;
40949 int res1 = 0 ;
40950 PyObject *swig_obj[1] ;
40951
40952 if (!args) SWIG_fail;
40953 swig_obj[0] = args;
40954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40957 }
40958 arg1 = reinterpret_cast< wxMenu * >(argp1);
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 result = (long)((wxMenu const *)arg1)->GetStyle();
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 resultobj = SWIG_From_long(static_cast< long >(result));
40966 return resultobj;
40967 fail:
40968 return NULL;
40969 }
40970
40971
40972 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40973 PyObject *resultobj = 0;
40974 wxMenu *arg1 = (wxMenu *) 0 ;
40975 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40976 void *argp1 = 0 ;
40977 int res1 = 0 ;
40978 void *argp2 = 0 ;
40979 int res2 = 0 ;
40980 PyObject * obj0 = 0 ;
40981 PyObject * obj1 = 0 ;
40982 char * kwnames[] = {
40983 (char *) "self",(char *) "source", NULL
40984 };
40985
40986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40988 if (!SWIG_IsOK(res1)) {
40989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40990 }
40991 arg1 = reinterpret_cast< wxMenu * >(argp1);
40992 if (obj1) {
40993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40994 if (!SWIG_IsOK(res2)) {
40995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40996 }
40997 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40998 }
40999 {
41000 PyThreadState* __tstate = wxPyBeginAllowThreads();
41001 (arg1)->UpdateUI(arg2);
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 resultobj = SWIG_Py_Void();
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41013 PyObject *resultobj = 0;
41014 wxMenu *arg1 = (wxMenu *) 0 ;
41015 wxMenuBar *result = 0 ;
41016 void *argp1 = 0 ;
41017 int res1 = 0 ;
41018 PyObject *swig_obj[1] ;
41019
41020 if (!args) SWIG_fail;
41021 swig_obj[0] = args;
41022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41023 if (!SWIG_IsOK(res1)) {
41024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41025 }
41026 arg1 = reinterpret_cast< wxMenu * >(argp1);
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41030 wxPyEndAllowThreads(__tstate);
41031 if (PyErr_Occurred()) SWIG_fail;
41032 }
41033 {
41034 resultobj = wxPyMake_wxObject(result, (bool)0);
41035 }
41036 return resultobj;
41037 fail:
41038 return NULL;
41039 }
41040
41041
41042 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41043 PyObject *resultobj = 0;
41044 wxMenu *arg1 = (wxMenu *) 0 ;
41045 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41046 void *argp1 = 0 ;
41047 int res1 = 0 ;
41048 void *argp2 = 0 ;
41049 int res2 = 0 ;
41050 PyObject * obj0 = 0 ;
41051 PyObject * obj1 = 0 ;
41052 char * kwnames[] = {
41053 (char *) "self",(char *) "menubar", NULL
41054 };
41055
41056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41058 if (!SWIG_IsOK(res1)) {
41059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41060 }
41061 arg1 = reinterpret_cast< wxMenu * >(argp1);
41062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41063 if (!SWIG_IsOK(res2)) {
41064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41065 }
41066 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 (arg1)->Attach(arg2);
41070 wxPyEndAllowThreads(__tstate);
41071 if (PyErr_Occurred()) SWIG_fail;
41072 }
41073 resultobj = SWIG_Py_Void();
41074 return resultobj;
41075 fail:
41076 return NULL;
41077 }
41078
41079
41080 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41081 PyObject *resultobj = 0;
41082 wxMenu *arg1 = (wxMenu *) 0 ;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 PyObject *swig_obj[1] ;
41086
41087 if (!args) SWIG_fail;
41088 swig_obj[0] = args;
41089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41090 if (!SWIG_IsOK(res1)) {
41091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41092 }
41093 arg1 = reinterpret_cast< wxMenu * >(argp1);
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 (arg1)->Detach();
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 resultobj = SWIG_Py_Void();
41101 return resultobj;
41102 fail:
41103 return NULL;
41104 }
41105
41106
41107 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41108 PyObject *resultobj = 0;
41109 wxMenu *arg1 = (wxMenu *) 0 ;
41110 bool result;
41111 void *argp1 = 0 ;
41112 int res1 = 0 ;
41113 PyObject *swig_obj[1] ;
41114
41115 if (!args) SWIG_fail;
41116 swig_obj[0] = args;
41117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41118 if (!SWIG_IsOK(res1)) {
41119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41120 }
41121 arg1 = reinterpret_cast< wxMenu * >(argp1);
41122 {
41123 PyThreadState* __tstate = wxPyBeginAllowThreads();
41124 result = (bool)((wxMenu const *)arg1)->IsAttached();
41125 wxPyEndAllowThreads(__tstate);
41126 if (PyErr_Occurred()) SWIG_fail;
41127 }
41128 {
41129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41130 }
41131 return resultobj;
41132 fail:
41133 return NULL;
41134 }
41135
41136
41137 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41138 PyObject *resultobj = 0;
41139 wxMenu *arg1 = (wxMenu *) 0 ;
41140 wxMenu *arg2 = (wxMenu *) 0 ;
41141 void *argp1 = 0 ;
41142 int res1 = 0 ;
41143 void *argp2 = 0 ;
41144 int res2 = 0 ;
41145 PyObject * obj0 = 0 ;
41146 PyObject * obj1 = 0 ;
41147 char * kwnames[] = {
41148 (char *) "self",(char *) "parent", NULL
41149 };
41150
41151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41153 if (!SWIG_IsOK(res1)) {
41154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41155 }
41156 arg1 = reinterpret_cast< wxMenu * >(argp1);
41157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41158 if (!SWIG_IsOK(res2)) {
41159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41160 }
41161 arg2 = reinterpret_cast< wxMenu * >(argp2);
41162 {
41163 PyThreadState* __tstate = wxPyBeginAllowThreads();
41164 (arg1)->SetParent(arg2);
41165 wxPyEndAllowThreads(__tstate);
41166 if (PyErr_Occurred()) SWIG_fail;
41167 }
41168 resultobj = SWIG_Py_Void();
41169 return resultobj;
41170 fail:
41171 return NULL;
41172 }
41173
41174
41175 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41176 PyObject *resultobj = 0;
41177 wxMenu *arg1 = (wxMenu *) 0 ;
41178 wxMenu *result = 0 ;
41179 void *argp1 = 0 ;
41180 int res1 = 0 ;
41181 PyObject *swig_obj[1] ;
41182
41183 if (!args) SWIG_fail;
41184 swig_obj[0] = args;
41185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41186 if (!SWIG_IsOK(res1)) {
41187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41188 }
41189 arg1 = reinterpret_cast< wxMenu * >(argp1);
41190 {
41191 PyThreadState* __tstate = wxPyBeginAllowThreads();
41192 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41193 wxPyEndAllowThreads(__tstate);
41194 if (PyErr_Occurred()) SWIG_fail;
41195 }
41196 {
41197 resultobj = wxPyMake_wxObject(result, 0);
41198 }
41199 return resultobj;
41200 fail:
41201 return NULL;
41202 }
41203
41204
41205 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41206 PyObject *obj;
41207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41208 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41209 return SWIG_Py_Void();
41210 }
41211
41212 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41213 return SWIG_Python_InitShadowInstance(args);
41214 }
41215
41216 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41217 PyObject *resultobj = 0;
41218 long arg1 = (long) 0 ;
41219 wxMenuBar *result = 0 ;
41220 long val1 ;
41221 int ecode1 = 0 ;
41222 PyObject * obj0 = 0 ;
41223 char * kwnames[] = {
41224 (char *) "style", NULL
41225 };
41226
41227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41228 if (obj0) {
41229 ecode1 = SWIG_AsVal_long(obj0, &val1);
41230 if (!SWIG_IsOK(ecode1)) {
41231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41232 }
41233 arg1 = static_cast< long >(val1);
41234 }
41235 {
41236 if (!wxPyCheckForApp()) SWIG_fail;
41237 PyThreadState* __tstate = wxPyBeginAllowThreads();
41238 result = (wxMenuBar *)new wxMenuBar(arg1);
41239 wxPyEndAllowThreads(__tstate);
41240 if (PyErr_Occurred()) SWIG_fail;
41241 }
41242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41243 return resultobj;
41244 fail:
41245 return NULL;
41246 }
41247
41248
41249 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41250 PyObject *resultobj = 0;
41251 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41252 wxMenu *arg2 = (wxMenu *) 0 ;
41253 wxString *arg3 = 0 ;
41254 bool result;
41255 void *argp1 = 0 ;
41256 int res1 = 0 ;
41257 void *argp2 = 0 ;
41258 int res2 = 0 ;
41259 bool temp3 = false ;
41260 PyObject * obj0 = 0 ;
41261 PyObject * obj1 = 0 ;
41262 PyObject * obj2 = 0 ;
41263 char * kwnames[] = {
41264 (char *) "self",(char *) "menu",(char *) "title", NULL
41265 };
41266
41267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41269 if (!SWIG_IsOK(res1)) {
41270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41271 }
41272 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41274 if (!SWIG_IsOK(res2)) {
41275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41276 }
41277 arg2 = reinterpret_cast< wxMenu * >(argp2);
41278 {
41279 arg3 = wxString_in_helper(obj2);
41280 if (arg3 == NULL) SWIG_fail;
41281 temp3 = true;
41282 }
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41286 wxPyEndAllowThreads(__tstate);
41287 if (PyErr_Occurred()) SWIG_fail;
41288 }
41289 {
41290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41291 }
41292 {
41293 if (temp3)
41294 delete arg3;
41295 }
41296 return resultobj;
41297 fail:
41298 {
41299 if (temp3)
41300 delete arg3;
41301 }
41302 return NULL;
41303 }
41304
41305
41306 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41307 PyObject *resultobj = 0;
41308 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41309 size_t arg2 ;
41310 wxMenu *arg3 = (wxMenu *) 0 ;
41311 wxString *arg4 = 0 ;
41312 bool result;
41313 void *argp1 = 0 ;
41314 int res1 = 0 ;
41315 size_t val2 ;
41316 int ecode2 = 0 ;
41317 void *argp3 = 0 ;
41318 int res3 = 0 ;
41319 bool temp4 = false ;
41320 PyObject * obj0 = 0 ;
41321 PyObject * obj1 = 0 ;
41322 PyObject * obj2 = 0 ;
41323 PyObject * obj3 = 0 ;
41324 char * kwnames[] = {
41325 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41326 };
41327
41328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41330 if (!SWIG_IsOK(res1)) {
41331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41332 }
41333 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41334 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41335 if (!SWIG_IsOK(ecode2)) {
41336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41337 }
41338 arg2 = static_cast< size_t >(val2);
41339 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41340 if (!SWIG_IsOK(res3)) {
41341 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41342 }
41343 arg3 = reinterpret_cast< wxMenu * >(argp3);
41344 {
41345 arg4 = wxString_in_helper(obj3);
41346 if (arg4 == NULL) SWIG_fail;
41347 temp4 = true;
41348 }
41349 {
41350 PyThreadState* __tstate = wxPyBeginAllowThreads();
41351 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41352 wxPyEndAllowThreads(__tstate);
41353 if (PyErr_Occurred()) SWIG_fail;
41354 }
41355 {
41356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41357 }
41358 {
41359 if (temp4)
41360 delete arg4;
41361 }
41362 return resultobj;
41363 fail:
41364 {
41365 if (temp4)
41366 delete arg4;
41367 }
41368 return NULL;
41369 }
41370
41371
41372 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41373 PyObject *resultobj = 0;
41374 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41375 size_t result;
41376 void *argp1 = 0 ;
41377 int res1 = 0 ;
41378 PyObject *swig_obj[1] ;
41379
41380 if (!args) SWIG_fail;
41381 swig_obj[0] = args;
41382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41383 if (!SWIG_IsOK(res1)) {
41384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41385 }
41386 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41387 {
41388 PyThreadState* __tstate = wxPyBeginAllowThreads();
41389 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41390 wxPyEndAllowThreads(__tstate);
41391 if (PyErr_Occurred()) SWIG_fail;
41392 }
41393 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41394 return resultobj;
41395 fail:
41396 return NULL;
41397 }
41398
41399
41400 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41401 PyObject *resultobj = 0;
41402 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41403 size_t arg2 ;
41404 wxMenu *result = 0 ;
41405 void *argp1 = 0 ;
41406 int res1 = 0 ;
41407 size_t val2 ;
41408 int ecode2 = 0 ;
41409 PyObject * obj0 = 0 ;
41410 PyObject * obj1 = 0 ;
41411 char * kwnames[] = {
41412 (char *) "self",(char *) "pos", NULL
41413 };
41414
41415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41417 if (!SWIG_IsOK(res1)) {
41418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41419 }
41420 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41421 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41422 if (!SWIG_IsOK(ecode2)) {
41423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41424 }
41425 arg2 = static_cast< size_t >(val2);
41426 {
41427 PyThreadState* __tstate = wxPyBeginAllowThreads();
41428 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 {
41433 resultobj = wxPyMake_wxObject(result, 0);
41434 }
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41442 PyObject *resultobj = 0;
41443 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41444 size_t arg2 ;
41445 wxMenu *arg3 = (wxMenu *) 0 ;
41446 wxString *arg4 = 0 ;
41447 wxMenu *result = 0 ;
41448 void *argp1 = 0 ;
41449 int res1 = 0 ;
41450 size_t val2 ;
41451 int ecode2 = 0 ;
41452 void *argp3 = 0 ;
41453 int res3 = 0 ;
41454 bool temp4 = false ;
41455 PyObject * obj0 = 0 ;
41456 PyObject * obj1 = 0 ;
41457 PyObject * obj2 = 0 ;
41458 PyObject * obj3 = 0 ;
41459 char * kwnames[] = {
41460 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41461 };
41462
41463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41465 if (!SWIG_IsOK(res1)) {
41466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41467 }
41468 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41469 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41470 if (!SWIG_IsOK(ecode2)) {
41471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41472 }
41473 arg2 = static_cast< size_t >(val2);
41474 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41475 if (!SWIG_IsOK(res3)) {
41476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41477 }
41478 arg3 = reinterpret_cast< wxMenu * >(argp3);
41479 {
41480 arg4 = wxString_in_helper(obj3);
41481 if (arg4 == NULL) SWIG_fail;
41482 temp4 = true;
41483 }
41484 {
41485 PyThreadState* __tstate = wxPyBeginAllowThreads();
41486 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 {
41491 resultobj = wxPyMake_wxObject(result, 0);
41492 }
41493 {
41494 if (temp4)
41495 delete arg4;
41496 }
41497 return resultobj;
41498 fail:
41499 {
41500 if (temp4)
41501 delete arg4;
41502 }
41503 return NULL;
41504 }
41505
41506
41507 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41508 PyObject *resultobj = 0;
41509 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41510 size_t arg2 ;
41511 wxMenu *result = 0 ;
41512 void *argp1 = 0 ;
41513 int res1 = 0 ;
41514 size_t val2 ;
41515 int ecode2 = 0 ;
41516 PyObject * obj0 = 0 ;
41517 PyObject * obj1 = 0 ;
41518 char * kwnames[] = {
41519 (char *) "self",(char *) "pos", NULL
41520 };
41521
41522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41526 }
41527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41529 if (!SWIG_IsOK(ecode2)) {
41530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41531 }
41532 arg2 = static_cast< size_t >(val2);
41533 {
41534 PyThreadState* __tstate = wxPyBeginAllowThreads();
41535 result = (wxMenu *)(arg1)->Remove(arg2);
41536 wxPyEndAllowThreads(__tstate);
41537 if (PyErr_Occurred()) SWIG_fail;
41538 }
41539 {
41540 resultobj = wxPyMake_wxObject(result, 0);
41541 }
41542 return resultobj;
41543 fail:
41544 return NULL;
41545 }
41546
41547
41548 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41549 PyObject *resultobj = 0;
41550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41551 size_t arg2 ;
41552 bool arg3 ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 size_t val2 ;
41556 int ecode2 = 0 ;
41557 bool val3 ;
41558 int ecode3 = 0 ;
41559 PyObject * obj0 = 0 ;
41560 PyObject * obj1 = 0 ;
41561 PyObject * obj2 = 0 ;
41562 char * kwnames[] = {
41563 (char *) "self",(char *) "pos",(char *) "enable", NULL
41564 };
41565
41566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41568 if (!SWIG_IsOK(res1)) {
41569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41570 }
41571 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41572 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41573 if (!SWIG_IsOK(ecode2)) {
41574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41575 }
41576 arg2 = static_cast< size_t >(val2);
41577 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41578 if (!SWIG_IsOK(ecode3)) {
41579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41580 }
41581 arg3 = static_cast< bool >(val3);
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 (arg1)->EnableTop(arg2,arg3);
41585 wxPyEndAllowThreads(__tstate);
41586 if (PyErr_Occurred()) SWIG_fail;
41587 }
41588 resultobj = SWIG_Py_Void();
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj = 0;
41597 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41598 size_t arg2 ;
41599 bool result;
41600 void *argp1 = 0 ;
41601 int res1 = 0 ;
41602 size_t val2 ;
41603 int ecode2 = 0 ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char * kwnames[] = {
41607 (char *) "self",(char *) "pos", NULL
41608 };
41609
41610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41612 if (!SWIG_IsOK(res1)) {
41613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41614 }
41615 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41616 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41617 if (!SWIG_IsOK(ecode2)) {
41618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41619 }
41620 arg2 = static_cast< size_t >(val2);
41621 {
41622 PyThreadState* __tstate = wxPyBeginAllowThreads();
41623 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41624 wxPyEndAllowThreads(__tstate);
41625 if (PyErr_Occurred()) SWIG_fail;
41626 }
41627 {
41628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41629 }
41630 return resultobj;
41631 fail:
41632 return NULL;
41633 }
41634
41635
41636 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41637 PyObject *resultobj = 0;
41638 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41639 size_t arg2 ;
41640 wxString *arg3 = 0 ;
41641 void *argp1 = 0 ;
41642 int res1 = 0 ;
41643 size_t val2 ;
41644 int ecode2 = 0 ;
41645 bool temp3 = false ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 PyObject * obj2 = 0 ;
41649 char * kwnames[] = {
41650 (char *) "self",(char *) "pos",(char *) "label", NULL
41651 };
41652
41653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41655 if (!SWIG_IsOK(res1)) {
41656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41657 }
41658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41659 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41660 if (!SWIG_IsOK(ecode2)) {
41661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41662 }
41663 arg2 = static_cast< size_t >(val2);
41664 {
41665 arg3 = wxString_in_helper(obj2);
41666 if (arg3 == NULL) SWIG_fail;
41667 temp3 = true;
41668 }
41669 {
41670 PyThreadState* __tstate = wxPyBeginAllowThreads();
41671 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41672 wxPyEndAllowThreads(__tstate);
41673 if (PyErr_Occurred()) SWIG_fail;
41674 }
41675 resultobj = SWIG_Py_Void();
41676 {
41677 if (temp3)
41678 delete arg3;
41679 }
41680 return resultobj;
41681 fail:
41682 {
41683 if (temp3)
41684 delete arg3;
41685 }
41686 return NULL;
41687 }
41688
41689
41690 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj = 0;
41692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41693 size_t arg2 ;
41694 wxString result;
41695 void *argp1 = 0 ;
41696 int res1 = 0 ;
41697 size_t val2 ;
41698 int ecode2 = 0 ;
41699 PyObject * obj0 = 0 ;
41700 PyObject * obj1 = 0 ;
41701 char * kwnames[] = {
41702 (char *) "self",(char *) "pos", NULL
41703 };
41704
41705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41707 if (!SWIG_IsOK(res1)) {
41708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41709 }
41710 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41711 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41712 if (!SWIG_IsOK(ecode2)) {
41713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41714 }
41715 arg2 = static_cast< size_t >(val2);
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 {
41723 #if wxUSE_UNICODE
41724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41725 #else
41726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41727 #endif
41728 }
41729 return resultobj;
41730 fail:
41731 return NULL;
41732 }
41733
41734
41735 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41736 PyObject *resultobj = 0;
41737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41738 wxString *arg2 = 0 ;
41739 wxString *arg3 = 0 ;
41740 int result;
41741 void *argp1 = 0 ;
41742 int res1 = 0 ;
41743 bool temp2 = false ;
41744 bool temp3 = false ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 PyObject * obj2 = 0 ;
41748 char * kwnames[] = {
41749 (char *) "self",(char *) "menu",(char *) "item", NULL
41750 };
41751
41752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41754 if (!SWIG_IsOK(res1)) {
41755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41756 }
41757 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41758 {
41759 arg2 = wxString_in_helper(obj1);
41760 if (arg2 == NULL) SWIG_fail;
41761 temp2 = true;
41762 }
41763 {
41764 arg3 = wxString_in_helper(obj2);
41765 if (arg3 == NULL) SWIG_fail;
41766 temp3 = true;
41767 }
41768 {
41769 PyThreadState* __tstate = wxPyBeginAllowThreads();
41770 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41771 wxPyEndAllowThreads(__tstate);
41772 if (PyErr_Occurred()) SWIG_fail;
41773 }
41774 resultobj = SWIG_From_int(static_cast< int >(result));
41775 {
41776 if (temp2)
41777 delete arg2;
41778 }
41779 {
41780 if (temp3)
41781 delete arg3;
41782 }
41783 return resultobj;
41784 fail:
41785 {
41786 if (temp2)
41787 delete arg2;
41788 }
41789 {
41790 if (temp3)
41791 delete arg3;
41792 }
41793 return NULL;
41794 }
41795
41796
41797 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj = 0;
41799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41800 int arg2 ;
41801 wxMenuItem *result = 0 ;
41802 void *argp1 = 0 ;
41803 int res1 = 0 ;
41804 int val2 ;
41805 int ecode2 = 0 ;
41806 PyObject * obj0 = 0 ;
41807 PyObject * obj1 = 0 ;
41808 char * kwnames[] = {
41809 (char *) "self",(char *) "id", NULL
41810 };
41811
41812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41814 if (!SWIG_IsOK(res1)) {
41815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41816 }
41817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41818 ecode2 = SWIG_AsVal_int(obj1, &val2);
41819 if (!SWIG_IsOK(ecode2)) {
41820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41821 }
41822 arg2 = static_cast< int >(val2);
41823 {
41824 PyThreadState* __tstate = wxPyBeginAllowThreads();
41825 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41826 wxPyEndAllowThreads(__tstate);
41827 if (PyErr_Occurred()) SWIG_fail;
41828 }
41829 {
41830 resultobj = wxPyMake_wxObject(result, (bool)0);
41831 }
41832 return resultobj;
41833 fail:
41834 return NULL;
41835 }
41836
41837
41838 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41839 PyObject *resultobj = 0;
41840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41841 wxString *arg2 = 0 ;
41842 int result;
41843 void *argp1 = 0 ;
41844 int res1 = 0 ;
41845 bool temp2 = false ;
41846 PyObject * obj0 = 0 ;
41847 PyObject * obj1 = 0 ;
41848 char * kwnames[] = {
41849 (char *) "self",(char *) "title", NULL
41850 };
41851
41852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41854 if (!SWIG_IsOK(res1)) {
41855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41856 }
41857 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41858 {
41859 arg2 = wxString_in_helper(obj1);
41860 if (arg2 == NULL) SWIG_fail;
41861 temp2 = true;
41862 }
41863 {
41864 PyThreadState* __tstate = wxPyBeginAllowThreads();
41865 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41866 wxPyEndAllowThreads(__tstate);
41867 if (PyErr_Occurred()) SWIG_fail;
41868 }
41869 resultobj = SWIG_From_int(static_cast< int >(result));
41870 {
41871 if (temp2)
41872 delete arg2;
41873 }
41874 return resultobj;
41875 fail:
41876 {
41877 if (temp2)
41878 delete arg2;
41879 }
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 int arg2 ;
41888 bool arg3 ;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 int val2 ;
41892 int ecode2 = 0 ;
41893 bool val3 ;
41894 int ecode3 = 0 ;
41895 PyObject * obj0 = 0 ;
41896 PyObject * obj1 = 0 ;
41897 PyObject * obj2 = 0 ;
41898 char * kwnames[] = {
41899 (char *) "self",(char *) "id",(char *) "enable", NULL
41900 };
41901
41902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41904 if (!SWIG_IsOK(res1)) {
41905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41906 }
41907 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41908 ecode2 = SWIG_AsVal_int(obj1, &val2);
41909 if (!SWIG_IsOK(ecode2)) {
41910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41911 }
41912 arg2 = static_cast< int >(val2);
41913 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41914 if (!SWIG_IsOK(ecode3)) {
41915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41916 }
41917 arg3 = static_cast< bool >(val3);
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 (arg1)->Enable(arg2,arg3);
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 resultobj = SWIG_Py_Void();
41925 return resultobj;
41926 fail:
41927 return NULL;
41928 }
41929
41930
41931 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41932 PyObject *resultobj = 0;
41933 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41934 int arg2 ;
41935 bool arg3 ;
41936 void *argp1 = 0 ;
41937 int res1 = 0 ;
41938 int val2 ;
41939 int ecode2 = 0 ;
41940 bool val3 ;
41941 int ecode3 = 0 ;
41942 PyObject * obj0 = 0 ;
41943 PyObject * obj1 = 0 ;
41944 PyObject * obj2 = 0 ;
41945 char * kwnames[] = {
41946 (char *) "self",(char *) "id",(char *) "check", NULL
41947 };
41948
41949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41951 if (!SWIG_IsOK(res1)) {
41952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41953 }
41954 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41955 ecode2 = SWIG_AsVal_int(obj1, &val2);
41956 if (!SWIG_IsOK(ecode2)) {
41957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41958 }
41959 arg2 = static_cast< int >(val2);
41960 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41961 if (!SWIG_IsOK(ecode3)) {
41962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41963 }
41964 arg3 = static_cast< bool >(val3);
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 (arg1)->Check(arg2,arg3);
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 resultobj = SWIG_Py_Void();
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41979 PyObject *resultobj = 0;
41980 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41981 int arg2 ;
41982 bool result;
41983 void *argp1 = 0 ;
41984 int res1 = 0 ;
41985 int val2 ;
41986 int ecode2 = 0 ;
41987 PyObject * obj0 = 0 ;
41988 PyObject * obj1 = 0 ;
41989 char * kwnames[] = {
41990 (char *) "self",(char *) "id", NULL
41991 };
41992
41993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41995 if (!SWIG_IsOK(res1)) {
41996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41997 }
41998 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41999 ecode2 = SWIG_AsVal_int(obj1, &val2);
42000 if (!SWIG_IsOK(ecode2)) {
42001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42002 }
42003 arg2 = static_cast< int >(val2);
42004 {
42005 PyThreadState* __tstate = wxPyBeginAllowThreads();
42006 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42007 wxPyEndAllowThreads(__tstate);
42008 if (PyErr_Occurred()) SWIG_fail;
42009 }
42010 {
42011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42012 }
42013 return resultobj;
42014 fail:
42015 return NULL;
42016 }
42017
42018
42019 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42020 PyObject *resultobj = 0;
42021 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42022 int arg2 ;
42023 bool result;
42024 void *argp1 = 0 ;
42025 int res1 = 0 ;
42026 int val2 ;
42027 int ecode2 = 0 ;
42028 PyObject * obj0 = 0 ;
42029 PyObject * obj1 = 0 ;
42030 char * kwnames[] = {
42031 (char *) "self",(char *) "id", NULL
42032 };
42033
42034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42036 if (!SWIG_IsOK(res1)) {
42037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42038 }
42039 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42040 ecode2 = SWIG_AsVal_int(obj1, &val2);
42041 if (!SWIG_IsOK(ecode2)) {
42042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42043 }
42044 arg2 = static_cast< int >(val2);
42045 {
42046 PyThreadState* __tstate = wxPyBeginAllowThreads();
42047 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 {
42052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42053 }
42054 return resultobj;
42055 fail:
42056 return NULL;
42057 }
42058
42059
42060 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42061 PyObject *resultobj = 0;
42062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42063 int arg2 ;
42064 wxString *arg3 = 0 ;
42065 void *argp1 = 0 ;
42066 int res1 = 0 ;
42067 int val2 ;
42068 int ecode2 = 0 ;
42069 bool temp3 = false ;
42070 PyObject * obj0 = 0 ;
42071 PyObject * obj1 = 0 ;
42072 PyObject * obj2 = 0 ;
42073 char * kwnames[] = {
42074 (char *) "self",(char *) "id",(char *) "label", NULL
42075 };
42076
42077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42079 if (!SWIG_IsOK(res1)) {
42080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42081 }
42082 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42083 ecode2 = SWIG_AsVal_int(obj1, &val2);
42084 if (!SWIG_IsOK(ecode2)) {
42085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42086 }
42087 arg2 = static_cast< int >(val2);
42088 {
42089 arg3 = wxString_in_helper(obj2);
42090 if (arg3 == NULL) SWIG_fail;
42091 temp3 = true;
42092 }
42093 {
42094 PyThreadState* __tstate = wxPyBeginAllowThreads();
42095 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42096 wxPyEndAllowThreads(__tstate);
42097 if (PyErr_Occurred()) SWIG_fail;
42098 }
42099 resultobj = SWIG_Py_Void();
42100 {
42101 if (temp3)
42102 delete arg3;
42103 }
42104 return resultobj;
42105 fail:
42106 {
42107 if (temp3)
42108 delete arg3;
42109 }
42110 return NULL;
42111 }
42112
42113
42114 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42115 PyObject *resultobj = 0;
42116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42117 int arg2 ;
42118 wxString result;
42119 void *argp1 = 0 ;
42120 int res1 = 0 ;
42121 int val2 ;
42122 int ecode2 = 0 ;
42123 PyObject * obj0 = 0 ;
42124 PyObject * obj1 = 0 ;
42125 char * kwnames[] = {
42126 (char *) "self",(char *) "id", NULL
42127 };
42128
42129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42131 if (!SWIG_IsOK(res1)) {
42132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42133 }
42134 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42135 ecode2 = SWIG_AsVal_int(obj1, &val2);
42136 if (!SWIG_IsOK(ecode2)) {
42137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42138 }
42139 arg2 = static_cast< int >(val2);
42140 {
42141 PyThreadState* __tstate = wxPyBeginAllowThreads();
42142 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42143 wxPyEndAllowThreads(__tstate);
42144 if (PyErr_Occurred()) SWIG_fail;
42145 }
42146 {
42147 #if wxUSE_UNICODE
42148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42149 #else
42150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42151 #endif
42152 }
42153 return resultobj;
42154 fail:
42155 return NULL;
42156 }
42157
42158
42159 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42160 PyObject *resultobj = 0;
42161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42162 int arg2 ;
42163 wxString *arg3 = 0 ;
42164 void *argp1 = 0 ;
42165 int res1 = 0 ;
42166 int val2 ;
42167 int ecode2 = 0 ;
42168 bool temp3 = false ;
42169 PyObject * obj0 = 0 ;
42170 PyObject * obj1 = 0 ;
42171 PyObject * obj2 = 0 ;
42172 char * kwnames[] = {
42173 (char *) "self",(char *) "id",(char *) "helpString", NULL
42174 };
42175
42176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42178 if (!SWIG_IsOK(res1)) {
42179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42180 }
42181 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42182 ecode2 = SWIG_AsVal_int(obj1, &val2);
42183 if (!SWIG_IsOK(ecode2)) {
42184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42185 }
42186 arg2 = static_cast< int >(val2);
42187 {
42188 arg3 = wxString_in_helper(obj2);
42189 if (arg3 == NULL) SWIG_fail;
42190 temp3 = true;
42191 }
42192 {
42193 PyThreadState* __tstate = wxPyBeginAllowThreads();
42194 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42195 wxPyEndAllowThreads(__tstate);
42196 if (PyErr_Occurred()) SWIG_fail;
42197 }
42198 resultobj = SWIG_Py_Void();
42199 {
42200 if (temp3)
42201 delete arg3;
42202 }
42203 return resultobj;
42204 fail:
42205 {
42206 if (temp3)
42207 delete arg3;
42208 }
42209 return NULL;
42210 }
42211
42212
42213 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj = 0;
42215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42216 int arg2 ;
42217 wxString result;
42218 void *argp1 = 0 ;
42219 int res1 = 0 ;
42220 int val2 ;
42221 int ecode2 = 0 ;
42222 PyObject * obj0 = 0 ;
42223 PyObject * obj1 = 0 ;
42224 char * kwnames[] = {
42225 (char *) "self",(char *) "id", NULL
42226 };
42227
42228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42230 if (!SWIG_IsOK(res1)) {
42231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42232 }
42233 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42234 ecode2 = SWIG_AsVal_int(obj1, &val2);
42235 if (!SWIG_IsOK(ecode2)) {
42236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42237 }
42238 arg2 = static_cast< int >(val2);
42239 {
42240 PyThreadState* __tstate = wxPyBeginAllowThreads();
42241 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42242 wxPyEndAllowThreads(__tstate);
42243 if (PyErr_Occurred()) SWIG_fail;
42244 }
42245 {
42246 #if wxUSE_UNICODE
42247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42248 #else
42249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42250 #endif
42251 }
42252 return resultobj;
42253 fail:
42254 return NULL;
42255 }
42256
42257
42258 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42259 PyObject *resultobj = 0;
42260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42261 wxFrame *result = 0 ;
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_wxMenuBar, 0 | 0 );
42269 if (!SWIG_IsOK(res1)) {
42270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42271 }
42272 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42273 {
42274 PyThreadState* __tstate = wxPyBeginAllowThreads();
42275 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42276 wxPyEndAllowThreads(__tstate);
42277 if (PyErr_Occurred()) SWIG_fail;
42278 }
42279 {
42280 resultobj = wxPyMake_wxObject(result, (bool)0);
42281 }
42282 return resultobj;
42283 fail:
42284 return NULL;
42285 }
42286
42287
42288 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42289 PyObject *resultobj = 0;
42290 wxMenuBar *arg1 = (wxMenuBar *) 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_wxMenuBar, 0 | 0 );
42299 if (!SWIG_IsOK(res1)) {
42300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42301 }
42302 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42303 {
42304 PyThreadState* __tstate = wxPyBeginAllowThreads();
42305 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
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_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42319 PyObject *resultobj = 0;
42320 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42321 wxFrame *arg2 = (wxFrame *) 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 *) "frame", NULL
42330 };
42331
42332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42334 if (!SWIG_IsOK(res1)) {
42335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42336 }
42337 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42339 if (!SWIG_IsOK(res2)) {
42340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42341 }
42342 arg2 = reinterpret_cast< wxFrame * >(argp2);
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 (arg1)->Attach(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_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42357 PyObject *resultobj = 0;
42358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42359 void *argp1 = 0 ;
42360 int res1 = 0 ;
42361 PyObject *swig_obj[1] ;
42362
42363 if (!args) SWIG_fail;
42364 swig_obj[0] = args;
42365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42366 if (!SWIG_IsOK(res1)) {
42367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42368 }
42369 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 (arg1)->Detach();
42373 wxPyEndAllowThreads(__tstate);
42374 if (PyErr_Occurred()) SWIG_fail;
42375 }
42376 resultobj = SWIG_Py_Void();
42377 return resultobj;
42378 fail:
42379 return NULL;
42380 }
42381
42382
42383 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42384 PyObject *resultobj = 0;
42385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42386 void *argp1 = 0 ;
42387 int res1 = 0 ;
42388 PyObject *swig_obj[1] ;
42389
42390 if (!args) SWIG_fail;
42391 swig_obj[0] = args;
42392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42393 if (!SWIG_IsOK(res1)) {
42394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42395 }
42396 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42397 {
42398 PyThreadState* __tstate = wxPyBeginAllowThreads();
42399 (arg1)->UpdateMenus();
42400 wxPyEndAllowThreads(__tstate);
42401 if (PyErr_Occurred()) SWIG_fail;
42402 }
42403 resultobj = SWIG_Py_Void();
42404 return resultobj;
42405 fail:
42406 return NULL;
42407 }
42408
42409
42410 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42411 PyObject *resultobj = 0;
42412 bool arg1 ;
42413 bool val1 ;
42414 int ecode1 = 0 ;
42415 PyObject * obj0 = 0 ;
42416 char * kwnames[] = {
42417 (char *) "enable", NULL
42418 };
42419
42420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42421 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42422 if (!SWIG_IsOK(ecode1)) {
42423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42424 }
42425 arg1 = static_cast< bool >(val1);
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 wxMenuBar_SetAutoWindowMenu(arg1);
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_Py_Void();
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42440 PyObject *resultobj = 0;
42441 bool result;
42442
42443 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42444 {
42445 PyThreadState* __tstate = wxPyBeginAllowThreads();
42446 result = (bool)wxMenuBar_GetAutoWindowMenu();
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 {
42451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42452 }
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42460 PyObject *obj;
42461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42462 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42463 return SWIG_Py_Void();
42464 }
42465
42466 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42467 return SWIG_Python_InitShadowInstance(args);
42468 }
42469
42470 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42471 PyObject *resultobj = 0;
42472 wxMenu *arg1 = (wxMenu *) NULL ;
42473 int arg2 = (int) wxID_ANY ;
42474 wxString const &arg3_defvalue = wxPyEmptyString ;
42475 wxString *arg3 = (wxString *) &arg3_defvalue ;
42476 wxString const &arg4_defvalue = wxPyEmptyString ;
42477 wxString *arg4 = (wxString *) &arg4_defvalue ;
42478 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42479 wxMenu *arg6 = (wxMenu *) NULL ;
42480 wxMenuItem *result = 0 ;
42481 void *argp1 = 0 ;
42482 int res1 = 0 ;
42483 int val2 ;
42484 int ecode2 = 0 ;
42485 bool temp3 = false ;
42486 bool temp4 = false ;
42487 int val5 ;
42488 int ecode5 = 0 ;
42489 void *argp6 = 0 ;
42490 int res6 = 0 ;
42491 PyObject * obj0 = 0 ;
42492 PyObject * obj1 = 0 ;
42493 PyObject * obj2 = 0 ;
42494 PyObject * obj3 = 0 ;
42495 PyObject * obj4 = 0 ;
42496 PyObject * obj5 = 0 ;
42497 char * kwnames[] = {
42498 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42499 };
42500
42501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42502 if (obj0) {
42503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42504 if (!SWIG_IsOK(res1)) {
42505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42506 }
42507 arg1 = reinterpret_cast< wxMenu * >(argp1);
42508 }
42509 if (obj1) {
42510 ecode2 = SWIG_AsVal_int(obj1, &val2);
42511 if (!SWIG_IsOK(ecode2)) {
42512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42513 }
42514 arg2 = static_cast< int >(val2);
42515 }
42516 if (obj2) {
42517 {
42518 arg3 = wxString_in_helper(obj2);
42519 if (arg3 == NULL) SWIG_fail;
42520 temp3 = true;
42521 }
42522 }
42523 if (obj3) {
42524 {
42525 arg4 = wxString_in_helper(obj3);
42526 if (arg4 == NULL) SWIG_fail;
42527 temp4 = true;
42528 }
42529 }
42530 if (obj4) {
42531 ecode5 = SWIG_AsVal_int(obj4, &val5);
42532 if (!SWIG_IsOK(ecode5)) {
42533 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42534 }
42535 arg5 = static_cast< wxItemKind >(val5);
42536 }
42537 if (obj5) {
42538 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42539 if (!SWIG_IsOK(res6)) {
42540 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42541 }
42542 arg6 = reinterpret_cast< wxMenu * >(argp6);
42543 }
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 {
42551 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42552 }
42553 {
42554 if (temp3)
42555 delete arg3;
42556 }
42557 {
42558 if (temp4)
42559 delete arg4;
42560 }
42561 return resultobj;
42562 fail:
42563 {
42564 if (temp3)
42565 delete arg3;
42566 }
42567 {
42568 if (temp4)
42569 delete arg4;
42570 }
42571 return NULL;
42572 }
42573
42574
42575 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42576 PyObject *resultobj = 0;
42577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42578 void *argp1 = 0 ;
42579 int res1 = 0 ;
42580 PyObject *swig_obj[1] ;
42581
42582 if (!args) SWIG_fail;
42583 swig_obj[0] = args;
42584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42585 if (!SWIG_IsOK(res1)) {
42586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42587 }
42588 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42589 {
42590 PyThreadState* __tstate = wxPyBeginAllowThreads();
42591 delete arg1;
42592
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 resultobj = SWIG_Py_Void();
42597 return resultobj;
42598 fail:
42599 return NULL;
42600 }
42601
42602
42603 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42604 PyObject *resultobj = 0;
42605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42606 wxMenu *result = 0 ;
42607 void *argp1 = 0 ;
42608 int res1 = 0 ;
42609 PyObject *swig_obj[1] ;
42610
42611 if (!args) SWIG_fail;
42612 swig_obj[0] = args;
42613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42614 if (!SWIG_IsOK(res1)) {
42615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42616 }
42617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42621 wxPyEndAllowThreads(__tstate);
42622 if (PyErr_Occurred()) SWIG_fail;
42623 }
42624 {
42625 resultobj = wxPyMake_wxObject(result, 0);
42626 }
42627 return resultobj;
42628 fail:
42629 return NULL;
42630 }
42631
42632
42633 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42634 PyObject *resultobj = 0;
42635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42636 wxMenu *arg2 = (wxMenu *) 0 ;
42637 void *argp1 = 0 ;
42638 int res1 = 0 ;
42639 void *argp2 = 0 ;
42640 int res2 = 0 ;
42641 PyObject * obj0 = 0 ;
42642 PyObject * obj1 = 0 ;
42643 char * kwnames[] = {
42644 (char *) "self",(char *) "menu", NULL
42645 };
42646
42647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42649 if (!SWIG_IsOK(res1)) {
42650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42651 }
42652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42654 if (!SWIG_IsOK(res2)) {
42655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42656 }
42657 arg2 = reinterpret_cast< wxMenu * >(argp2);
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 (arg1)->SetMenu(arg2);
42661 wxPyEndAllowThreads(__tstate);
42662 if (PyErr_Occurred()) SWIG_fail;
42663 }
42664 resultobj = SWIG_Py_Void();
42665 return resultobj;
42666 fail:
42667 return NULL;
42668 }
42669
42670
42671 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42672 PyObject *resultobj = 0;
42673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42674 int arg2 ;
42675 void *argp1 = 0 ;
42676 int res1 = 0 ;
42677 int val2 ;
42678 int ecode2 = 0 ;
42679 PyObject * obj0 = 0 ;
42680 PyObject * obj1 = 0 ;
42681 char * kwnames[] = {
42682 (char *) "self",(char *) "id", NULL
42683 };
42684
42685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42687 if (!SWIG_IsOK(res1)) {
42688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42689 }
42690 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42691 ecode2 = SWIG_AsVal_int(obj1, &val2);
42692 if (!SWIG_IsOK(ecode2)) {
42693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42694 }
42695 arg2 = static_cast< int >(val2);
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 (arg1)->SetId(arg2);
42699 wxPyEndAllowThreads(__tstate);
42700 if (PyErr_Occurred()) SWIG_fail;
42701 }
42702 resultobj = SWIG_Py_Void();
42703 return resultobj;
42704 fail:
42705 return NULL;
42706 }
42707
42708
42709 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42710 PyObject *resultobj = 0;
42711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42712 int result;
42713 void *argp1 = 0 ;
42714 int res1 = 0 ;
42715 PyObject *swig_obj[1] ;
42716
42717 if (!args) SWIG_fail;
42718 swig_obj[0] = args;
42719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42720 if (!SWIG_IsOK(res1)) {
42721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42722 }
42723 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (int)((wxMenuItem const *)arg1)->GetId();
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 resultobj = SWIG_From_int(static_cast< int >(result));
42731 return resultobj;
42732 fail:
42733 return NULL;
42734 }
42735
42736
42737 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42738 PyObject *resultobj = 0;
42739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42740 bool result;
42741 void *argp1 = 0 ;
42742 int res1 = 0 ;
42743 PyObject *swig_obj[1] ;
42744
42745 if (!args) SWIG_fail;
42746 swig_obj[0] = args;
42747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42748 if (!SWIG_IsOK(res1)) {
42749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42750 }
42751 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42752 {
42753 PyThreadState* __tstate = wxPyBeginAllowThreads();
42754 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42755 wxPyEndAllowThreads(__tstate);
42756 if (PyErr_Occurred()) SWIG_fail;
42757 }
42758 {
42759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42760 }
42761 return resultobj;
42762 fail:
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42770 wxString *arg2 = 0 ;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 bool temp2 = false ;
42774 PyObject * obj0 = 0 ;
42775 PyObject * obj1 = 0 ;
42776 char * kwnames[] = {
42777 (char *) "self",(char *) "str", NULL
42778 };
42779
42780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42782 if (!SWIG_IsOK(res1)) {
42783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42784 }
42785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42786 {
42787 arg2 = wxString_in_helper(obj1);
42788 if (arg2 == NULL) SWIG_fail;
42789 temp2 = true;
42790 }
42791 {
42792 PyThreadState* __tstate = wxPyBeginAllowThreads();
42793 (arg1)->SetText((wxString const &)*arg2);
42794 wxPyEndAllowThreads(__tstate);
42795 if (PyErr_Occurred()) SWIG_fail;
42796 }
42797 resultobj = SWIG_Py_Void();
42798 {
42799 if (temp2)
42800 delete arg2;
42801 }
42802 return resultobj;
42803 fail:
42804 {
42805 if (temp2)
42806 delete arg2;
42807 }
42808 return NULL;
42809 }
42810
42811
42812 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42813 PyObject *resultobj = 0;
42814 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42815 wxString result;
42816 void *argp1 = 0 ;
42817 int res1 = 0 ;
42818 PyObject *swig_obj[1] ;
42819
42820 if (!args) SWIG_fail;
42821 swig_obj[0] = args;
42822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42823 if (!SWIG_IsOK(res1)) {
42824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42825 }
42826 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42827 {
42828 PyThreadState* __tstate = wxPyBeginAllowThreads();
42829 result = ((wxMenuItem const *)arg1)->GetLabel();
42830 wxPyEndAllowThreads(__tstate);
42831 if (PyErr_Occurred()) SWIG_fail;
42832 }
42833 {
42834 #if wxUSE_UNICODE
42835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42836 #else
42837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42838 #endif
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42847 PyObject *resultobj = 0;
42848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42849 wxString *result = 0 ;
42850 void *argp1 = 0 ;
42851 int res1 = 0 ;
42852 PyObject *swig_obj[1] ;
42853
42854 if (!args) SWIG_fail;
42855 swig_obj[0] = args;
42856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42861 {
42862 PyThreadState* __tstate = wxPyBeginAllowThreads();
42863 {
42864 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42865 result = (wxString *) &_result_ref;
42866 }
42867 wxPyEndAllowThreads(__tstate);
42868 if (PyErr_Occurred()) SWIG_fail;
42869 }
42870 {
42871 #if wxUSE_UNICODE
42872 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42873 #else
42874 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42875 #endif
42876 }
42877 return resultobj;
42878 fail:
42879 return NULL;
42880 }
42881
42882
42883 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42884 PyObject *resultobj = 0;
42885 wxString *arg1 = 0 ;
42886 wxString result;
42887 bool temp1 = false ;
42888 PyObject * obj0 = 0 ;
42889 char * kwnames[] = {
42890 (char *) "text", NULL
42891 };
42892
42893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42894 {
42895 arg1 = wxString_in_helper(obj0);
42896 if (arg1 == NULL) SWIG_fail;
42897 temp1 = true;
42898 }
42899 {
42900 PyThreadState* __tstate = wxPyBeginAllowThreads();
42901 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42902 wxPyEndAllowThreads(__tstate);
42903 if (PyErr_Occurred()) SWIG_fail;
42904 }
42905 {
42906 #if wxUSE_UNICODE
42907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42908 #else
42909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42910 #endif
42911 }
42912 {
42913 if (temp1)
42914 delete arg1;
42915 }
42916 return resultobj;
42917 fail:
42918 {
42919 if (temp1)
42920 delete arg1;
42921 }
42922 return NULL;
42923 }
42924
42925
42926 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42927 PyObject *resultobj = 0;
42928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42929 wxItemKind result;
42930 void *argp1 = 0 ;
42931 int res1 = 0 ;
42932 PyObject *swig_obj[1] ;
42933
42934 if (!args) SWIG_fail;
42935 swig_obj[0] = args;
42936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42937 if (!SWIG_IsOK(res1)) {
42938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42939 }
42940 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42941 {
42942 PyThreadState* __tstate = wxPyBeginAllowThreads();
42943 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42944 wxPyEndAllowThreads(__tstate);
42945 if (PyErr_Occurred()) SWIG_fail;
42946 }
42947 resultobj = SWIG_From_int(static_cast< int >(result));
42948 return resultobj;
42949 fail:
42950 return NULL;
42951 }
42952
42953
42954 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42955 PyObject *resultobj = 0;
42956 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42957 wxItemKind arg2 ;
42958 void *argp1 = 0 ;
42959 int res1 = 0 ;
42960 int val2 ;
42961 int ecode2 = 0 ;
42962 PyObject * obj0 = 0 ;
42963 PyObject * obj1 = 0 ;
42964 char * kwnames[] = {
42965 (char *) "self",(char *) "kind", NULL
42966 };
42967
42968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42970 if (!SWIG_IsOK(res1)) {
42971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42972 }
42973 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42974 ecode2 = SWIG_AsVal_int(obj1, &val2);
42975 if (!SWIG_IsOK(ecode2)) {
42976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42977 }
42978 arg2 = static_cast< wxItemKind >(val2);
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 (arg1)->SetKind(arg2);
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 resultobj = SWIG_Py_Void();
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj = 0;
42994 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42995 bool arg2 ;
42996 void *argp1 = 0 ;
42997 int res1 = 0 ;
42998 bool val2 ;
42999 int ecode2 = 0 ;
43000 PyObject * obj0 = 0 ;
43001 PyObject * obj1 = 0 ;
43002 char * kwnames[] = {
43003 (char *) "self",(char *) "checkable", NULL
43004 };
43005
43006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43008 if (!SWIG_IsOK(res1)) {
43009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43010 }
43011 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43012 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43013 if (!SWIG_IsOK(ecode2)) {
43014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43015 }
43016 arg2 = static_cast< bool >(val2);
43017 {
43018 PyThreadState* __tstate = wxPyBeginAllowThreads();
43019 (arg1)->SetCheckable(arg2);
43020 wxPyEndAllowThreads(__tstate);
43021 if (PyErr_Occurred()) SWIG_fail;
43022 }
43023 resultobj = SWIG_Py_Void();
43024 return resultobj;
43025 fail:
43026 return NULL;
43027 }
43028
43029
43030 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43031 PyObject *resultobj = 0;
43032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43033 bool result;
43034 void *argp1 = 0 ;
43035 int res1 = 0 ;
43036 PyObject *swig_obj[1] ;
43037
43038 if (!args) SWIG_fail;
43039 swig_obj[0] = args;
43040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43041 if (!SWIG_IsOK(res1)) {
43042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43043 }
43044 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43045 {
43046 PyThreadState* __tstate = wxPyBeginAllowThreads();
43047 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43048 wxPyEndAllowThreads(__tstate);
43049 if (PyErr_Occurred()) SWIG_fail;
43050 }
43051 {
43052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43053 }
43054 return resultobj;
43055 fail:
43056 return NULL;
43057 }
43058
43059
43060 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43061 PyObject *resultobj = 0;
43062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43063 bool result;
43064 void *argp1 = 0 ;
43065 int res1 = 0 ;
43066 PyObject *swig_obj[1] ;
43067
43068 if (!args) SWIG_fail;
43069 swig_obj[0] = args;
43070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43071 if (!SWIG_IsOK(res1)) {
43072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43073 }
43074 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 {
43082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43083 }
43084 return resultobj;
43085 fail:
43086 return NULL;
43087 }
43088
43089
43090 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43091 PyObject *resultobj = 0;
43092 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43093 wxMenu *arg2 = (wxMenu *) 0 ;
43094 void *argp1 = 0 ;
43095 int res1 = 0 ;
43096 void *argp2 = 0 ;
43097 int res2 = 0 ;
43098 PyObject * obj0 = 0 ;
43099 PyObject * obj1 = 0 ;
43100 char * kwnames[] = {
43101 (char *) "self",(char *) "menu", NULL
43102 };
43103
43104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43106 if (!SWIG_IsOK(res1)) {
43107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43108 }
43109 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43111 if (!SWIG_IsOK(res2)) {
43112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43113 }
43114 arg2 = reinterpret_cast< wxMenu * >(argp2);
43115 {
43116 PyThreadState* __tstate = wxPyBeginAllowThreads();
43117 (arg1)->SetSubMenu(arg2);
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 resultobj = SWIG_Py_Void();
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43129 PyObject *resultobj = 0;
43130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43131 wxMenu *result = 0 ;
43132 void *argp1 = 0 ;
43133 int res1 = 0 ;
43134 PyObject *swig_obj[1] ;
43135
43136 if (!args) SWIG_fail;
43137 swig_obj[0] = args;
43138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43139 if (!SWIG_IsOK(res1)) {
43140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43141 }
43142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 {
43150 resultobj = wxPyMake_wxObject(result, 0);
43151 }
43152 return resultobj;
43153 fail:
43154 return NULL;
43155 }
43156
43157
43158 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43159 PyObject *resultobj = 0;
43160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43161 bool arg2 = (bool) true ;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 bool val2 ;
43165 int ecode2 = 0 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char * kwnames[] = {
43169 (char *) "self",(char *) "enable", NULL
43170 };
43171
43172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43178 if (obj1) {
43179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43180 if (!SWIG_IsOK(ecode2)) {
43181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43182 }
43183 arg2 = static_cast< bool >(val2);
43184 }
43185 {
43186 PyThreadState* __tstate = wxPyBeginAllowThreads();
43187 (arg1)->Enable(arg2);
43188 wxPyEndAllowThreads(__tstate);
43189 if (PyErr_Occurred()) SWIG_fail;
43190 }
43191 resultobj = SWIG_Py_Void();
43192 return resultobj;
43193 fail:
43194 return NULL;
43195 }
43196
43197
43198 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43199 PyObject *resultobj = 0;
43200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43201 bool result;
43202 void *argp1 = 0 ;
43203 int res1 = 0 ;
43204 PyObject *swig_obj[1] ;
43205
43206 if (!args) SWIG_fail;
43207 swig_obj[0] = args;
43208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43209 if (!SWIG_IsOK(res1)) {
43210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43211 }
43212 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43213 {
43214 PyThreadState* __tstate = wxPyBeginAllowThreads();
43215 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 {
43220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43221 }
43222 return resultobj;
43223 fail:
43224 return NULL;
43225 }
43226
43227
43228 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43229 PyObject *resultobj = 0;
43230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43231 bool arg2 = (bool) true ;
43232 void *argp1 = 0 ;
43233 int res1 = 0 ;
43234 bool val2 ;
43235 int ecode2 = 0 ;
43236 PyObject * obj0 = 0 ;
43237 PyObject * obj1 = 0 ;
43238 char * kwnames[] = {
43239 (char *) "self",(char *) "check", NULL
43240 };
43241
43242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43244 if (!SWIG_IsOK(res1)) {
43245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43246 }
43247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43248 if (obj1) {
43249 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43250 if (!SWIG_IsOK(ecode2)) {
43251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43252 }
43253 arg2 = static_cast< bool >(val2);
43254 }
43255 {
43256 PyThreadState* __tstate = wxPyBeginAllowThreads();
43257 (arg1)->Check(arg2);
43258 wxPyEndAllowThreads(__tstate);
43259 if (PyErr_Occurred()) SWIG_fail;
43260 }
43261 resultobj = SWIG_Py_Void();
43262 return resultobj;
43263 fail:
43264 return NULL;
43265 }
43266
43267
43268 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43269 PyObject *resultobj = 0;
43270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43271 bool result;
43272 void *argp1 = 0 ;
43273 int res1 = 0 ;
43274 PyObject *swig_obj[1] ;
43275
43276 if (!args) SWIG_fail;
43277 swig_obj[0] = args;
43278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43279 if (!SWIG_IsOK(res1)) {
43280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43281 }
43282 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43283 {
43284 PyThreadState* __tstate = wxPyBeginAllowThreads();
43285 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43286 wxPyEndAllowThreads(__tstate);
43287 if (PyErr_Occurred()) SWIG_fail;
43288 }
43289 {
43290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43291 }
43292 return resultobj;
43293 fail:
43294 return NULL;
43295 }
43296
43297
43298 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43299 PyObject *resultobj = 0;
43300 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43301 void *argp1 = 0 ;
43302 int res1 = 0 ;
43303 PyObject *swig_obj[1] ;
43304
43305 if (!args) SWIG_fail;
43306 swig_obj[0] = args;
43307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43308 if (!SWIG_IsOK(res1)) {
43309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43310 }
43311 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43312 {
43313 PyThreadState* __tstate = wxPyBeginAllowThreads();
43314 (arg1)->Toggle();
43315 wxPyEndAllowThreads(__tstate);
43316 if (PyErr_Occurred()) SWIG_fail;
43317 }
43318 resultobj = SWIG_Py_Void();
43319 return resultobj;
43320 fail:
43321 return NULL;
43322 }
43323
43324
43325 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43326 PyObject *resultobj = 0;
43327 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43328 wxString *arg2 = 0 ;
43329 void *argp1 = 0 ;
43330 int res1 = 0 ;
43331 bool temp2 = false ;
43332 PyObject * obj0 = 0 ;
43333 PyObject * obj1 = 0 ;
43334 char * kwnames[] = {
43335 (char *) "self",(char *) "str", NULL
43336 };
43337
43338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43340 if (!SWIG_IsOK(res1)) {
43341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43342 }
43343 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43344 {
43345 arg2 = wxString_in_helper(obj1);
43346 if (arg2 == NULL) SWIG_fail;
43347 temp2 = true;
43348 }
43349 {
43350 PyThreadState* __tstate = wxPyBeginAllowThreads();
43351 (arg1)->SetHelp((wxString const &)*arg2);
43352 wxPyEndAllowThreads(__tstate);
43353 if (PyErr_Occurred()) SWIG_fail;
43354 }
43355 resultobj = SWIG_Py_Void();
43356 {
43357 if (temp2)
43358 delete arg2;
43359 }
43360 return resultobj;
43361 fail:
43362 {
43363 if (temp2)
43364 delete arg2;
43365 }
43366 return NULL;
43367 }
43368
43369
43370 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43371 PyObject *resultobj = 0;
43372 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43373 wxString *result = 0 ;
43374 void *argp1 = 0 ;
43375 int res1 = 0 ;
43376 PyObject *swig_obj[1] ;
43377
43378 if (!args) SWIG_fail;
43379 swig_obj[0] = args;
43380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43381 if (!SWIG_IsOK(res1)) {
43382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43383 }
43384 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43385 {
43386 PyThreadState* __tstate = wxPyBeginAllowThreads();
43387 {
43388 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43389 result = (wxString *) &_result_ref;
43390 }
43391 wxPyEndAllowThreads(__tstate);
43392 if (PyErr_Occurred()) SWIG_fail;
43393 }
43394 {
43395 #if wxUSE_UNICODE
43396 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43397 #else
43398 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43399 #endif
43400 }
43401 return resultobj;
43402 fail:
43403 return NULL;
43404 }
43405
43406
43407 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43408 PyObject *resultobj = 0;
43409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43410 wxAcceleratorEntry *result = 0 ;
43411 void *argp1 = 0 ;
43412 int res1 = 0 ;
43413 PyObject *swig_obj[1] ;
43414
43415 if (!args) SWIG_fail;
43416 swig_obj[0] = args;
43417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43418 if (!SWIG_IsOK(res1)) {
43419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43420 }
43421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43422 {
43423 PyThreadState* __tstate = wxPyBeginAllowThreads();
43424 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43429 return resultobj;
43430 fail:
43431 return NULL;
43432 }
43433
43434
43435 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43436 PyObject *resultobj = 0;
43437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43438 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43439 void *argp1 = 0 ;
43440 int res1 = 0 ;
43441 void *argp2 = 0 ;
43442 int res2 = 0 ;
43443 PyObject * obj0 = 0 ;
43444 PyObject * obj1 = 0 ;
43445 char * kwnames[] = {
43446 (char *) "self",(char *) "accel", NULL
43447 };
43448
43449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43451 if (!SWIG_IsOK(res1)) {
43452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43453 }
43454 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43456 if (!SWIG_IsOK(res2)) {
43457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43458 }
43459 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43460 {
43461 PyThreadState* __tstate = wxPyBeginAllowThreads();
43462 (arg1)->SetAccel(arg2);
43463 wxPyEndAllowThreads(__tstate);
43464 if (PyErr_Occurred()) SWIG_fail;
43465 }
43466 resultobj = SWIG_Py_Void();
43467 return resultobj;
43468 fail:
43469 return NULL;
43470 }
43471
43472
43473 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43474 PyObject *resultobj = 0;
43475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43476 wxBitmap *arg2 = 0 ;
43477 void *argp1 = 0 ;
43478 int res1 = 0 ;
43479 void *argp2 = 0 ;
43480 int res2 = 0 ;
43481 PyObject * obj0 = 0 ;
43482 PyObject * obj1 = 0 ;
43483 char * kwnames[] = {
43484 (char *) "self",(char *) "bitmap", NULL
43485 };
43486
43487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43489 if (!SWIG_IsOK(res1)) {
43490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43491 }
43492 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43494 if (!SWIG_IsOK(res2)) {
43495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43496 }
43497 if (!argp2) {
43498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43499 }
43500 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 resultobj = SWIG_Py_Void();
43508 return resultobj;
43509 fail:
43510 return NULL;
43511 }
43512
43513
43514 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43515 PyObject *resultobj = 0;
43516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43517 wxBitmap *result = 0 ;
43518 void *argp1 = 0 ;
43519 int res1 = 0 ;
43520 PyObject *swig_obj[1] ;
43521
43522 if (!args) SWIG_fail;
43523 swig_obj[0] = args;
43524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43525 if (!SWIG_IsOK(res1)) {
43526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43527 }
43528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43529 {
43530 PyThreadState* __tstate = wxPyBeginAllowThreads();
43531 {
43532 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43533 result = (wxBitmap *) &_result_ref;
43534 }
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 {
43539 wxBitmap* resultptr = new wxBitmap(*result);
43540 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43541 }
43542 return resultobj;
43543 fail:
43544 return NULL;
43545 }
43546
43547
43548 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43549 PyObject *resultobj = 0;
43550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43551 wxFont *arg2 = 0 ;
43552 void *argp1 = 0 ;
43553 int res1 = 0 ;
43554 void *argp2 = 0 ;
43555 int res2 = 0 ;
43556 PyObject * obj0 = 0 ;
43557 PyObject * obj1 = 0 ;
43558 char * kwnames[] = {
43559 (char *) "self",(char *) "font", NULL
43560 };
43561
43562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43564 if (!SWIG_IsOK(res1)) {
43565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43566 }
43567 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43568 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43569 if (!SWIG_IsOK(res2)) {
43570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43571 }
43572 if (!argp2) {
43573 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43574 }
43575 arg2 = reinterpret_cast< wxFont * >(argp2);
43576 {
43577 PyThreadState* __tstate = wxPyBeginAllowThreads();
43578 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43579 wxPyEndAllowThreads(__tstate);
43580 if (PyErr_Occurred()) SWIG_fail;
43581 }
43582 resultobj = SWIG_Py_Void();
43583 return resultobj;
43584 fail:
43585 return NULL;
43586 }
43587
43588
43589 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43590 PyObject *resultobj = 0;
43591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43592 wxFont result;
43593 void *argp1 = 0 ;
43594 int res1 = 0 ;
43595 PyObject *swig_obj[1] ;
43596
43597 if (!args) SWIG_fail;
43598 swig_obj[0] = args;
43599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43600 if (!SWIG_IsOK(res1)) {
43601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43602 }
43603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43604 {
43605 PyThreadState* __tstate = wxPyBeginAllowThreads();
43606 result = wxMenuItem_GetFont(arg1);
43607 wxPyEndAllowThreads(__tstate);
43608 if (PyErr_Occurred()) SWIG_fail;
43609 }
43610 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43611 return resultobj;
43612 fail:
43613 return NULL;
43614 }
43615
43616
43617 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43618 PyObject *resultobj = 0;
43619 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43620 wxColour *arg2 = 0 ;
43621 void *argp1 = 0 ;
43622 int res1 = 0 ;
43623 wxColour temp2 ;
43624 PyObject * obj0 = 0 ;
43625 PyObject * obj1 = 0 ;
43626 char * kwnames[] = {
43627 (char *) "self",(char *) "colText", NULL
43628 };
43629
43630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43632 if (!SWIG_IsOK(res1)) {
43633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43634 }
43635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43636 {
43637 arg2 = &temp2;
43638 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43639 }
43640 {
43641 PyThreadState* __tstate = wxPyBeginAllowThreads();
43642 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43643 wxPyEndAllowThreads(__tstate);
43644 if (PyErr_Occurred()) SWIG_fail;
43645 }
43646 resultobj = SWIG_Py_Void();
43647 return resultobj;
43648 fail:
43649 return NULL;
43650 }
43651
43652
43653 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43654 PyObject *resultobj = 0;
43655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43656 wxColour result;
43657 void *argp1 = 0 ;
43658 int res1 = 0 ;
43659 PyObject *swig_obj[1] ;
43660
43661 if (!args) SWIG_fail;
43662 swig_obj[0] = args;
43663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43664 if (!SWIG_IsOK(res1)) {
43665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43666 }
43667 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43668 {
43669 PyThreadState* __tstate = wxPyBeginAllowThreads();
43670 result = wxMenuItem_GetTextColour(arg1);
43671 wxPyEndAllowThreads(__tstate);
43672 if (PyErr_Occurred()) SWIG_fail;
43673 }
43674 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43675 return resultobj;
43676 fail:
43677 return NULL;
43678 }
43679
43680
43681 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43682 PyObject *resultobj = 0;
43683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43684 wxColour *arg2 = 0 ;
43685 void *argp1 = 0 ;
43686 int res1 = 0 ;
43687 wxColour temp2 ;
43688 PyObject * obj0 = 0 ;
43689 PyObject * obj1 = 0 ;
43690 char * kwnames[] = {
43691 (char *) "self",(char *) "colBack", NULL
43692 };
43693
43694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43696 if (!SWIG_IsOK(res1)) {
43697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43698 }
43699 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43700 {
43701 arg2 = &temp2;
43702 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43703 }
43704 {
43705 PyThreadState* __tstate = wxPyBeginAllowThreads();
43706 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43707 wxPyEndAllowThreads(__tstate);
43708 if (PyErr_Occurred()) SWIG_fail;
43709 }
43710 resultobj = SWIG_Py_Void();
43711 return resultobj;
43712 fail:
43713 return NULL;
43714 }
43715
43716
43717 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43718 PyObject *resultobj = 0;
43719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43720 wxColour result;
43721 void *argp1 = 0 ;
43722 int res1 = 0 ;
43723 PyObject *swig_obj[1] ;
43724
43725 if (!args) SWIG_fail;
43726 swig_obj[0] = args;
43727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43728 if (!SWIG_IsOK(res1)) {
43729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43730 }
43731 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43732 {
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 result = wxMenuItem_GetBackgroundColour(arg1);
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43746 PyObject *resultobj = 0;
43747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43748 wxBitmap *arg2 = 0 ;
43749 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43750 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43751 void *argp1 = 0 ;
43752 int res1 = 0 ;
43753 void *argp2 = 0 ;
43754 int res2 = 0 ;
43755 void *argp3 = 0 ;
43756 int res3 = 0 ;
43757 PyObject * obj0 = 0 ;
43758 PyObject * obj1 = 0 ;
43759 PyObject * obj2 = 0 ;
43760 char * kwnames[] = {
43761 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43762 };
43763
43764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43766 if (!SWIG_IsOK(res1)) {
43767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43768 }
43769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43771 if (!SWIG_IsOK(res2)) {
43772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43773 }
43774 if (!argp2) {
43775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43776 }
43777 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43778 if (obj2) {
43779 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43780 if (!SWIG_IsOK(res3)) {
43781 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43782 }
43783 if (!argp3) {
43784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43785 }
43786 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43787 }
43788 {
43789 PyThreadState* __tstate = wxPyBeginAllowThreads();
43790 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43791 wxPyEndAllowThreads(__tstate);
43792 if (PyErr_Occurred()) SWIG_fail;
43793 }
43794 resultobj = SWIG_Py_Void();
43795 return resultobj;
43796 fail:
43797 return NULL;
43798 }
43799
43800
43801 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43802 PyObject *resultobj = 0;
43803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43804 wxBitmap *arg2 = 0 ;
43805 void *argp1 = 0 ;
43806 int res1 = 0 ;
43807 void *argp2 = 0 ;
43808 int res2 = 0 ;
43809 PyObject * obj0 = 0 ;
43810 PyObject * obj1 = 0 ;
43811 char * kwnames[] = {
43812 (char *) "self",(char *) "bmpDisabled", NULL
43813 };
43814
43815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43817 if (!SWIG_IsOK(res1)) {
43818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43819 }
43820 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43822 if (!SWIG_IsOK(res2)) {
43823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43824 }
43825 if (!argp2) {
43826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43827 }
43828 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43829 {
43830 PyThreadState* __tstate = wxPyBeginAllowThreads();
43831 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43832 wxPyEndAllowThreads(__tstate);
43833 if (PyErr_Occurred()) SWIG_fail;
43834 }
43835 resultobj = SWIG_Py_Void();
43836 return resultobj;
43837 fail:
43838 return NULL;
43839 }
43840
43841
43842 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43843 PyObject *resultobj = 0;
43844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43845 wxBitmap *result = 0 ;
43846 void *argp1 = 0 ;
43847 int res1 = 0 ;
43848 PyObject *swig_obj[1] ;
43849
43850 if (!args) SWIG_fail;
43851 swig_obj[0] = args;
43852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43853 if (!SWIG_IsOK(res1)) {
43854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43855 }
43856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43857 {
43858 PyThreadState* __tstate = wxPyBeginAllowThreads();
43859 {
43860 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43861 result = (wxBitmap *) &_result_ref;
43862 }
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 {
43867 wxBitmap* resultptr = new wxBitmap(*result);
43868 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43869 }
43870 return resultobj;
43871 fail:
43872 return NULL;
43873 }
43874
43875
43876 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43877 PyObject *resultobj = 0;
43878 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43879 int arg2 ;
43880 void *argp1 = 0 ;
43881 int res1 = 0 ;
43882 int val2 ;
43883 int ecode2 = 0 ;
43884 PyObject * obj0 = 0 ;
43885 PyObject * obj1 = 0 ;
43886 char * kwnames[] = {
43887 (char *) "self",(char *) "nWidth", NULL
43888 };
43889
43890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43892 if (!SWIG_IsOK(res1)) {
43893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43894 }
43895 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43896 ecode2 = SWIG_AsVal_int(obj1, &val2);
43897 if (!SWIG_IsOK(ecode2)) {
43898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43899 }
43900 arg2 = static_cast< int >(val2);
43901 {
43902 PyThreadState* __tstate = wxPyBeginAllowThreads();
43903 wxMenuItem_SetMarginWidth(arg1,arg2);
43904 wxPyEndAllowThreads(__tstate);
43905 if (PyErr_Occurred()) SWIG_fail;
43906 }
43907 resultobj = SWIG_Py_Void();
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43915 PyObject *resultobj = 0;
43916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43917 int result;
43918 void *argp1 = 0 ;
43919 int res1 = 0 ;
43920 PyObject *swig_obj[1] ;
43921
43922 if (!args) SWIG_fail;
43923 swig_obj[0] = args;
43924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43925 if (!SWIG_IsOK(res1)) {
43926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43927 }
43928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 result = (int)wxMenuItem_GetMarginWidth(arg1);
43932 wxPyEndAllowThreads(__tstate);
43933 if (PyErr_Occurred()) SWIG_fail;
43934 }
43935 resultobj = SWIG_From_int(static_cast< int >(result));
43936 return resultobj;
43937 fail:
43938 return NULL;
43939 }
43940
43941
43942 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43943 PyObject *resultobj = 0;
43944 int result;
43945
43946 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 result = (int)wxMenuItem_GetDefaultMarginWidth();
43950 wxPyEndAllowThreads(__tstate);
43951 if (PyErr_Occurred()) SWIG_fail;
43952 }
43953 resultobj = SWIG_From_int(static_cast< int >(result));
43954 return resultobj;
43955 fail:
43956 return NULL;
43957 }
43958
43959
43960 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43961 PyObject *resultobj = 0;
43962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43963 bool result;
43964 void *argp1 = 0 ;
43965 int res1 = 0 ;
43966 PyObject *swig_obj[1] ;
43967
43968 if (!args) SWIG_fail;
43969 swig_obj[0] = args;
43970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43971 if (!SWIG_IsOK(res1)) {
43972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43973 }
43974 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43975 {
43976 PyThreadState* __tstate = wxPyBeginAllowThreads();
43977 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 {
43982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43983 }
43984 return resultobj;
43985 fail:
43986 return NULL;
43987 }
43988
43989
43990 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43991 PyObject *resultobj = 0;
43992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43993 bool arg2 = (bool) true ;
43994 void *argp1 = 0 ;
43995 int res1 = 0 ;
43996 bool val2 ;
43997 int ecode2 = 0 ;
43998 PyObject * obj0 = 0 ;
43999 PyObject * obj1 = 0 ;
44000 char * kwnames[] = {
44001 (char *) "self",(char *) "ownerDrawn", NULL
44002 };
44003
44004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44006 if (!SWIG_IsOK(res1)) {
44007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44008 }
44009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44010 if (obj1) {
44011 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44012 if (!SWIG_IsOK(ecode2)) {
44013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44014 }
44015 arg2 = static_cast< bool >(val2);
44016 }
44017 {
44018 PyThreadState* __tstate = wxPyBeginAllowThreads();
44019 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44020 wxPyEndAllowThreads(__tstate);
44021 if (PyErr_Occurred()) SWIG_fail;
44022 }
44023 resultobj = SWIG_Py_Void();
44024 return resultobj;
44025 fail:
44026 return NULL;
44027 }
44028
44029
44030 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44031 PyObject *resultobj = 0;
44032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44033 void *argp1 = 0 ;
44034 int res1 = 0 ;
44035 PyObject *swig_obj[1] ;
44036
44037 if (!args) SWIG_fail;
44038 swig_obj[0] = args;
44039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44040 if (!SWIG_IsOK(res1)) {
44041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44042 }
44043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44044 {
44045 PyThreadState* __tstate = wxPyBeginAllowThreads();
44046 wxMenuItem_ResetOwnerDrawn(arg1);
44047 wxPyEndAllowThreads(__tstate);
44048 if (PyErr_Occurred()) SWIG_fail;
44049 }
44050 resultobj = SWIG_Py_Void();
44051 return resultobj;
44052 fail:
44053 return NULL;
44054 }
44055
44056
44057 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44058 PyObject *obj;
44059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44060 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44061 return SWIG_Py_Void();
44062 }
44063
44064 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44065 return SWIG_Python_InitShadowInstance(args);
44066 }
44067
44068 SWIGINTERN int ControlNameStr_set(PyObject *) {
44069 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44070 return 1;
44071 }
44072
44073
44074 SWIGINTERN PyObject *ControlNameStr_get(void) {
44075 PyObject *pyobj = 0;
44076
44077 {
44078 #if wxUSE_UNICODE
44079 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44080 #else
44081 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44082 #endif
44083 }
44084 return pyobj;
44085 }
44086
44087
44088 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44089 PyObject *resultobj = 0;
44090 wxWindow *arg1 = (wxWindow *) 0 ;
44091 int arg2 = (int) -1 ;
44092 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44093 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44094 wxSize const &arg4_defvalue = wxDefaultSize ;
44095 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44096 long arg5 = (long) 0 ;
44097 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44098 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44099 wxString const &arg7_defvalue = wxPyControlNameStr ;
44100 wxString *arg7 = (wxString *) &arg7_defvalue ;
44101 wxControl *result = 0 ;
44102 void *argp1 = 0 ;
44103 int res1 = 0 ;
44104 int val2 ;
44105 int ecode2 = 0 ;
44106 wxPoint temp3 ;
44107 wxSize temp4 ;
44108 long val5 ;
44109 int ecode5 = 0 ;
44110 void *argp6 = 0 ;
44111 int res6 = 0 ;
44112 bool temp7 = false ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 PyObject * obj2 = 0 ;
44116 PyObject * obj3 = 0 ;
44117 PyObject * obj4 = 0 ;
44118 PyObject * obj5 = 0 ;
44119 PyObject * obj6 = 0 ;
44120 char * kwnames[] = {
44121 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44122 };
44123
44124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44128 }
44129 arg1 = reinterpret_cast< wxWindow * >(argp1);
44130 if (obj1) {
44131 ecode2 = SWIG_AsVal_int(obj1, &val2);
44132 if (!SWIG_IsOK(ecode2)) {
44133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44134 }
44135 arg2 = static_cast< int >(val2);
44136 }
44137 if (obj2) {
44138 {
44139 arg3 = &temp3;
44140 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44141 }
44142 }
44143 if (obj3) {
44144 {
44145 arg4 = &temp4;
44146 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44147 }
44148 }
44149 if (obj4) {
44150 ecode5 = SWIG_AsVal_long(obj4, &val5);
44151 if (!SWIG_IsOK(ecode5)) {
44152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44153 }
44154 arg5 = static_cast< long >(val5);
44155 }
44156 if (obj5) {
44157 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44158 if (!SWIG_IsOK(res6)) {
44159 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44160 }
44161 if (!argp6) {
44162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44163 }
44164 arg6 = reinterpret_cast< wxValidator * >(argp6);
44165 }
44166 if (obj6) {
44167 {
44168 arg7 = wxString_in_helper(obj6);
44169 if (arg7 == NULL) SWIG_fail;
44170 temp7 = true;
44171 }
44172 }
44173 {
44174 if (!wxPyCheckForApp()) SWIG_fail;
44175 PyThreadState* __tstate = wxPyBeginAllowThreads();
44176 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44177 wxPyEndAllowThreads(__tstate);
44178 if (PyErr_Occurred()) SWIG_fail;
44179 }
44180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44181 {
44182 if (temp7)
44183 delete arg7;
44184 }
44185 return resultobj;
44186 fail:
44187 {
44188 if (temp7)
44189 delete arg7;
44190 }
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44196 PyObject *resultobj = 0;
44197 wxControl *result = 0 ;
44198
44199 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44200 {
44201 if (!wxPyCheckForApp()) SWIG_fail;
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 result = (wxControl *)new wxControl();
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44208 return resultobj;
44209 fail:
44210 return NULL;
44211 }
44212
44213
44214 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44215 PyObject *resultobj = 0;
44216 wxControl *arg1 = (wxControl *) 0 ;
44217 wxWindow *arg2 = (wxWindow *) 0 ;
44218 int arg3 = (int) -1 ;
44219 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44220 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44221 wxSize const &arg5_defvalue = wxDefaultSize ;
44222 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44223 long arg6 = (long) 0 ;
44224 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44225 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44226 wxString const &arg8_defvalue = wxPyControlNameStr ;
44227 wxString *arg8 = (wxString *) &arg8_defvalue ;
44228 bool result;
44229 void *argp1 = 0 ;
44230 int res1 = 0 ;
44231 void *argp2 = 0 ;
44232 int res2 = 0 ;
44233 int val3 ;
44234 int ecode3 = 0 ;
44235 wxPoint temp4 ;
44236 wxSize temp5 ;
44237 long val6 ;
44238 int ecode6 = 0 ;
44239 void *argp7 = 0 ;
44240 int res7 = 0 ;
44241 bool temp8 = false ;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244 PyObject * obj2 = 0 ;
44245 PyObject * obj3 = 0 ;
44246 PyObject * obj4 = 0 ;
44247 PyObject * obj5 = 0 ;
44248 PyObject * obj6 = 0 ;
44249 PyObject * obj7 = 0 ;
44250 char * kwnames[] = {
44251 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44252 };
44253
44254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44256 if (!SWIG_IsOK(res1)) {
44257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44258 }
44259 arg1 = reinterpret_cast< wxControl * >(argp1);
44260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44261 if (!SWIG_IsOK(res2)) {
44262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44263 }
44264 arg2 = reinterpret_cast< wxWindow * >(argp2);
44265 if (obj2) {
44266 ecode3 = SWIG_AsVal_int(obj2, &val3);
44267 if (!SWIG_IsOK(ecode3)) {
44268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44269 }
44270 arg3 = static_cast< int >(val3);
44271 }
44272 if (obj3) {
44273 {
44274 arg4 = &temp4;
44275 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44276 }
44277 }
44278 if (obj4) {
44279 {
44280 arg5 = &temp5;
44281 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44282 }
44283 }
44284 if (obj5) {
44285 ecode6 = SWIG_AsVal_long(obj5, &val6);
44286 if (!SWIG_IsOK(ecode6)) {
44287 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44288 }
44289 arg6 = static_cast< long >(val6);
44290 }
44291 if (obj6) {
44292 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44293 if (!SWIG_IsOK(res7)) {
44294 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44295 }
44296 if (!argp7) {
44297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44298 }
44299 arg7 = reinterpret_cast< wxValidator * >(argp7);
44300 }
44301 if (obj7) {
44302 {
44303 arg8 = wxString_in_helper(obj7);
44304 if (arg8 == NULL) SWIG_fail;
44305 temp8 = true;
44306 }
44307 }
44308 {
44309 PyThreadState* __tstate = wxPyBeginAllowThreads();
44310 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44311 wxPyEndAllowThreads(__tstate);
44312 if (PyErr_Occurred()) SWIG_fail;
44313 }
44314 {
44315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44316 }
44317 {
44318 if (temp8)
44319 delete arg8;
44320 }
44321 return resultobj;
44322 fail:
44323 {
44324 if (temp8)
44325 delete arg8;
44326 }
44327 return NULL;
44328 }
44329
44330
44331 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44332 PyObject *resultobj = 0;
44333 wxControl *arg1 = (wxControl *) 0 ;
44334 int result;
44335 void *argp1 = 0 ;
44336 int res1 = 0 ;
44337 PyObject *swig_obj[1] ;
44338
44339 if (!args) SWIG_fail;
44340 swig_obj[0] = args;
44341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44342 if (!SWIG_IsOK(res1)) {
44343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44344 }
44345 arg1 = reinterpret_cast< wxControl * >(argp1);
44346 {
44347 PyThreadState* __tstate = wxPyBeginAllowThreads();
44348 result = (int)((wxControl const *)arg1)->GetAlignment();
44349 wxPyEndAllowThreads(__tstate);
44350 if (PyErr_Occurred()) SWIG_fail;
44351 }
44352 resultobj = SWIG_From_int(static_cast< int >(result));
44353 return resultobj;
44354 fail:
44355 return NULL;
44356 }
44357
44358
44359 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44360 PyObject *resultobj = 0;
44361 wxControl *arg1 = (wxControl *) 0 ;
44362 wxString result;
44363 void *argp1 = 0 ;
44364 int res1 = 0 ;
44365 PyObject *swig_obj[1] ;
44366
44367 if (!args) SWIG_fail;
44368 swig_obj[0] = args;
44369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44370 if (!SWIG_IsOK(res1)) {
44371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44372 }
44373 arg1 = reinterpret_cast< wxControl * >(argp1);
44374 {
44375 PyThreadState* __tstate = wxPyBeginAllowThreads();
44376 result = ((wxControl const *)arg1)->GetLabelText();
44377 wxPyEndAllowThreads(__tstate);
44378 if (PyErr_Occurred()) SWIG_fail;
44379 }
44380 {
44381 #if wxUSE_UNICODE
44382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44383 #else
44384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44385 #endif
44386 }
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxControl *arg1 = (wxControl *) 0 ;
44396 wxCommandEvent *arg2 = 0 ;
44397 void *argp1 = 0 ;
44398 int res1 = 0 ;
44399 void *argp2 = 0 ;
44400 int res2 = 0 ;
44401 PyObject * obj0 = 0 ;
44402 PyObject * obj1 = 0 ;
44403 char * kwnames[] = {
44404 (char *) "self",(char *) "event", NULL
44405 };
44406
44407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44409 if (!SWIG_IsOK(res1)) {
44410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44411 }
44412 arg1 = reinterpret_cast< wxControl * >(argp1);
44413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44414 if (!SWIG_IsOK(res2)) {
44415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44416 }
44417 if (!argp2) {
44418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44419 }
44420 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44421 {
44422 PyThreadState* __tstate = wxPyBeginAllowThreads();
44423 (arg1)->Command(*arg2);
44424 wxPyEndAllowThreads(__tstate);
44425 if (PyErr_Occurred()) SWIG_fail;
44426 }
44427 resultobj = SWIG_Py_Void();
44428 return resultobj;
44429 fail:
44430 return NULL;
44431 }
44432
44433
44434 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44435 PyObject *resultobj = 0;
44436 wxControl *arg1 = (wxControl *) 0 ;
44437 wxString result;
44438 void *argp1 = 0 ;
44439 int res1 = 0 ;
44440 PyObject *swig_obj[1] ;
44441
44442 if (!args) SWIG_fail;
44443 swig_obj[0] = args;
44444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44445 if (!SWIG_IsOK(res1)) {
44446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44447 }
44448 arg1 = reinterpret_cast< wxControl * >(argp1);
44449 {
44450 PyThreadState* __tstate = wxPyBeginAllowThreads();
44451 result = (arg1)->GetLabel();
44452 wxPyEndAllowThreads(__tstate);
44453 if (PyErr_Occurred()) SWIG_fail;
44454 }
44455 {
44456 #if wxUSE_UNICODE
44457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44458 #else
44459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44460 #endif
44461 }
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44469 PyObject *resultobj = 0;
44470 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44471 SwigValueWrapper<wxVisualAttributes > result;
44472 int val1 ;
44473 int ecode1 = 0 ;
44474 PyObject * obj0 = 0 ;
44475 char * kwnames[] = {
44476 (char *) "variant", NULL
44477 };
44478
44479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44480 if (obj0) {
44481 ecode1 = SWIG_AsVal_int(obj0, &val1);
44482 if (!SWIG_IsOK(ecode1)) {
44483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44484 }
44485 arg1 = static_cast< wxWindowVariant >(val1);
44486 }
44487 {
44488 if (!wxPyCheckForApp()) SWIG_fail;
44489 PyThreadState* __tstate = wxPyBeginAllowThreads();
44490 result = wxControl::GetClassDefaultAttributes(arg1);
44491 wxPyEndAllowThreads(__tstate);
44492 if (PyErr_Occurred()) SWIG_fail;
44493 }
44494 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44495 return resultobj;
44496 fail:
44497 return NULL;
44498 }
44499
44500
44501 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44502 PyObject *obj;
44503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44504 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44505 return SWIG_Py_Void();
44506 }
44507
44508 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44509 return SWIG_Python_InitShadowInstance(args);
44510 }
44511
44512 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44513 PyObject *resultobj = 0;
44514 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44515 wxString *arg2 = 0 ;
44516 PyObject *arg3 = (PyObject *) NULL ;
44517 int result;
44518 void *argp1 = 0 ;
44519 int res1 = 0 ;
44520 bool temp2 = false ;
44521 PyObject * obj0 = 0 ;
44522 PyObject * obj1 = 0 ;
44523 PyObject * obj2 = 0 ;
44524 char * kwnames[] = {
44525 (char *) "self",(char *) "item",(char *) "clientData", NULL
44526 };
44527
44528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44530 if (!SWIG_IsOK(res1)) {
44531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44532 }
44533 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44534 {
44535 arg2 = wxString_in_helper(obj1);
44536 if (arg2 == NULL) SWIG_fail;
44537 temp2 = true;
44538 }
44539 if (obj2) {
44540 arg3 = obj2;
44541 }
44542 {
44543 PyThreadState* __tstate = wxPyBeginAllowThreads();
44544 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44545 wxPyEndAllowThreads(__tstate);
44546 if (PyErr_Occurred()) SWIG_fail;
44547 }
44548 resultobj = SWIG_From_int(static_cast< int >(result));
44549 {
44550 if (temp2)
44551 delete arg2;
44552 }
44553 return resultobj;
44554 fail:
44555 {
44556 if (temp2)
44557 delete arg2;
44558 }
44559 return NULL;
44560 }
44561
44562
44563 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44564 PyObject *resultobj = 0;
44565 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44566 wxArrayString *arg2 = 0 ;
44567 void *argp1 = 0 ;
44568 int res1 = 0 ;
44569 bool temp2 = false ;
44570 PyObject * obj0 = 0 ;
44571 PyObject * obj1 = 0 ;
44572 char * kwnames[] = {
44573 (char *) "self",(char *) "strings", NULL
44574 };
44575
44576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44578 if (!SWIG_IsOK(res1)) {
44579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44580 }
44581 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44582 {
44583 if (! PySequence_Check(obj1)) {
44584 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44585 SWIG_fail;
44586 }
44587 arg2 = new wxArrayString;
44588 temp2 = true;
44589 int i, len=PySequence_Length(obj1);
44590 for (i=0; i<len; i++) {
44591 PyObject* item = PySequence_GetItem(obj1, i);
44592 wxString* s = wxString_in_helper(item);
44593 if (PyErr_Occurred()) SWIG_fail;
44594 arg2->Add(*s);
44595 delete s;
44596 Py_DECREF(item);
44597 }
44598 }
44599 {
44600 PyThreadState* __tstate = wxPyBeginAllowThreads();
44601 (arg1)->Append((wxArrayString const &)*arg2);
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 resultobj = SWIG_Py_Void();
44606 {
44607 if (temp2) delete arg2;
44608 }
44609 return resultobj;
44610 fail:
44611 {
44612 if (temp2) delete arg2;
44613 }
44614 return NULL;
44615 }
44616
44617
44618 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44619 PyObject *resultobj = 0;
44620 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44621 wxString *arg2 = 0 ;
44622 unsigned int arg3 ;
44623 PyObject *arg4 = (PyObject *) NULL ;
44624 int result;
44625 void *argp1 = 0 ;
44626 int res1 = 0 ;
44627 bool temp2 = false ;
44628 unsigned int val3 ;
44629 int ecode3 = 0 ;
44630 PyObject * obj0 = 0 ;
44631 PyObject * obj1 = 0 ;
44632 PyObject * obj2 = 0 ;
44633 PyObject * obj3 = 0 ;
44634 char * kwnames[] = {
44635 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44636 };
44637
44638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44640 if (!SWIG_IsOK(res1)) {
44641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44642 }
44643 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44644 {
44645 arg2 = wxString_in_helper(obj1);
44646 if (arg2 == NULL) SWIG_fail;
44647 temp2 = true;
44648 }
44649 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44650 if (!SWIG_IsOK(ecode3)) {
44651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44652 }
44653 arg3 = static_cast< unsigned int >(val3);
44654 if (obj3) {
44655 arg4 = obj3;
44656 }
44657 {
44658 PyThreadState* __tstate = wxPyBeginAllowThreads();
44659 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44660 wxPyEndAllowThreads(__tstate);
44661 if (PyErr_Occurred()) SWIG_fail;
44662 }
44663 resultobj = SWIG_From_int(static_cast< int >(result));
44664 {
44665 if (temp2)
44666 delete arg2;
44667 }
44668 return resultobj;
44669 fail:
44670 {
44671 if (temp2)
44672 delete arg2;
44673 }
44674 return NULL;
44675 }
44676
44677
44678 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44679 PyObject *resultobj = 0;
44680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44681 void *argp1 = 0 ;
44682 int res1 = 0 ;
44683 PyObject *swig_obj[1] ;
44684
44685 if (!args) SWIG_fail;
44686 swig_obj[0] = args;
44687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44688 if (!SWIG_IsOK(res1)) {
44689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44690 }
44691 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44692 {
44693 PyThreadState* __tstate = wxPyBeginAllowThreads();
44694 (arg1)->Clear();
44695 wxPyEndAllowThreads(__tstate);
44696 if (PyErr_Occurred()) SWIG_fail;
44697 }
44698 resultobj = SWIG_Py_Void();
44699 return resultobj;
44700 fail:
44701 return NULL;
44702 }
44703
44704
44705 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44706 PyObject *resultobj = 0;
44707 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44708 unsigned int arg2 ;
44709 void *argp1 = 0 ;
44710 int res1 = 0 ;
44711 unsigned int val2 ;
44712 int ecode2 = 0 ;
44713 PyObject * obj0 = 0 ;
44714 PyObject * obj1 = 0 ;
44715 char * kwnames[] = {
44716 (char *) "self",(char *) "n", NULL
44717 };
44718
44719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44721 if (!SWIG_IsOK(res1)) {
44722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44723 }
44724 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44725 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44726 if (!SWIG_IsOK(ecode2)) {
44727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44728 }
44729 arg2 = static_cast< unsigned int >(val2);
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 (arg1)->Delete(arg2);
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 resultobj = SWIG_Py_Void();
44737 return resultobj;
44738 fail:
44739 return NULL;
44740 }
44741
44742
44743 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44744 PyObject *resultobj = 0;
44745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44746 unsigned int arg2 ;
44747 PyObject *result = 0 ;
44748 void *argp1 = 0 ;
44749 int res1 = 0 ;
44750 unsigned int val2 ;
44751 int ecode2 = 0 ;
44752 PyObject * obj0 = 0 ;
44753 PyObject * obj1 = 0 ;
44754 char * kwnames[] = {
44755 (char *) "self",(char *) "n", NULL
44756 };
44757
44758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44760 if (!SWIG_IsOK(res1)) {
44761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44762 }
44763 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44764 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44765 if (!SWIG_IsOK(ecode2)) {
44766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44767 }
44768 arg2 = static_cast< unsigned int >(val2);
44769 {
44770 PyThreadState* __tstate = wxPyBeginAllowThreads();
44771 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44772 wxPyEndAllowThreads(__tstate);
44773 if (PyErr_Occurred()) SWIG_fail;
44774 }
44775 resultobj = result;
44776 return resultobj;
44777 fail:
44778 return NULL;
44779 }
44780
44781
44782 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44783 PyObject *resultobj = 0;
44784 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44785 unsigned int arg2 ;
44786 PyObject *arg3 = (PyObject *) 0 ;
44787 void *argp1 = 0 ;
44788 int res1 = 0 ;
44789 unsigned int val2 ;
44790 int ecode2 = 0 ;
44791 PyObject * obj0 = 0 ;
44792 PyObject * obj1 = 0 ;
44793 PyObject * obj2 = 0 ;
44794 char * kwnames[] = {
44795 (char *) "self",(char *) "n",(char *) "clientData", NULL
44796 };
44797
44798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44800 if (!SWIG_IsOK(res1)) {
44801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44802 }
44803 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44804 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44805 if (!SWIG_IsOK(ecode2)) {
44806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44807 }
44808 arg2 = static_cast< unsigned int >(val2);
44809 arg3 = obj2;
44810 {
44811 PyThreadState* __tstate = wxPyBeginAllowThreads();
44812 wxItemContainer_SetClientData(arg1,arg2,arg3);
44813 wxPyEndAllowThreads(__tstate);
44814 if (PyErr_Occurred()) SWIG_fail;
44815 }
44816 resultobj = SWIG_Py_Void();
44817 return resultobj;
44818 fail:
44819 return NULL;
44820 }
44821
44822
44823 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44824 PyObject *resultobj = 0;
44825 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44826 unsigned int result;
44827 void *argp1 = 0 ;
44828 int res1 = 0 ;
44829 PyObject *swig_obj[1] ;
44830
44831 if (!args) SWIG_fail;
44832 swig_obj[0] = args;
44833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44834 if (!SWIG_IsOK(res1)) {
44835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44836 }
44837 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44838 {
44839 PyThreadState* __tstate = wxPyBeginAllowThreads();
44840 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44841 wxPyEndAllowThreads(__tstate);
44842 if (PyErr_Occurred()) SWIG_fail;
44843 }
44844 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44845 return resultobj;
44846 fail:
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44852 PyObject *resultobj = 0;
44853 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44854 bool result;
44855 void *argp1 = 0 ;
44856 int res1 = 0 ;
44857 PyObject *swig_obj[1] ;
44858
44859 if (!args) SWIG_fail;
44860 swig_obj[0] = args;
44861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44862 if (!SWIG_IsOK(res1)) {
44863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44864 }
44865 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44866 {
44867 PyThreadState* __tstate = wxPyBeginAllowThreads();
44868 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44869 wxPyEndAllowThreads(__tstate);
44870 if (PyErr_Occurred()) SWIG_fail;
44871 }
44872 {
44873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44874 }
44875 return resultobj;
44876 fail:
44877 return NULL;
44878 }
44879
44880
44881 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44882 PyObject *resultobj = 0;
44883 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44884 unsigned int arg2 ;
44885 wxString result;
44886 void *argp1 = 0 ;
44887 int res1 = 0 ;
44888 unsigned int val2 ;
44889 int ecode2 = 0 ;
44890 PyObject * obj0 = 0 ;
44891 PyObject * obj1 = 0 ;
44892 char * kwnames[] = {
44893 (char *) "self",(char *) "n", NULL
44894 };
44895
44896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44898 if (!SWIG_IsOK(res1)) {
44899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44900 }
44901 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44902 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44903 if (!SWIG_IsOK(ecode2)) {
44904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44905 }
44906 arg2 = static_cast< unsigned int >(val2);
44907 {
44908 PyThreadState* __tstate = wxPyBeginAllowThreads();
44909 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44910 wxPyEndAllowThreads(__tstate);
44911 if (PyErr_Occurred()) SWIG_fail;
44912 }
44913 {
44914 #if wxUSE_UNICODE
44915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44916 #else
44917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44918 #endif
44919 }
44920 return resultobj;
44921 fail:
44922 return NULL;
44923 }
44924
44925
44926 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44927 PyObject *resultobj = 0;
44928 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44929 wxArrayString result;
44930 void *argp1 = 0 ;
44931 int res1 = 0 ;
44932 PyObject *swig_obj[1] ;
44933
44934 if (!args) SWIG_fail;
44935 swig_obj[0] = args;
44936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44937 if (!SWIG_IsOK(res1)) {
44938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44939 }
44940 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44941 {
44942 PyThreadState* __tstate = wxPyBeginAllowThreads();
44943 result = ((wxItemContainer const *)arg1)->GetStrings();
44944 wxPyEndAllowThreads(__tstate);
44945 if (PyErr_Occurred()) SWIG_fail;
44946 }
44947 {
44948 resultobj = wxArrayString2PyList_helper(result);
44949 }
44950 return resultobj;
44951 fail:
44952 return NULL;
44953 }
44954
44955
44956 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44957 PyObject *resultobj = 0;
44958 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44959 unsigned int arg2 ;
44960 wxString *arg3 = 0 ;
44961 void *argp1 = 0 ;
44962 int res1 = 0 ;
44963 unsigned int val2 ;
44964 int ecode2 = 0 ;
44965 bool temp3 = false ;
44966 PyObject * obj0 = 0 ;
44967 PyObject * obj1 = 0 ;
44968 PyObject * obj2 = 0 ;
44969 char * kwnames[] = {
44970 (char *) "self",(char *) "n",(char *) "s", NULL
44971 };
44972
44973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44975 if (!SWIG_IsOK(res1)) {
44976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44977 }
44978 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44979 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44980 if (!SWIG_IsOK(ecode2)) {
44981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44982 }
44983 arg2 = static_cast< unsigned int >(val2);
44984 {
44985 arg3 = wxString_in_helper(obj2);
44986 if (arg3 == NULL) SWIG_fail;
44987 temp3 = true;
44988 }
44989 {
44990 PyThreadState* __tstate = wxPyBeginAllowThreads();
44991 (arg1)->SetString(arg2,(wxString const &)*arg3);
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 resultobj = SWIG_Py_Void();
44996 {
44997 if (temp3)
44998 delete arg3;
44999 }
45000 return resultobj;
45001 fail:
45002 {
45003 if (temp3)
45004 delete arg3;
45005 }
45006 return NULL;
45007 }
45008
45009
45010 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45011 PyObject *resultobj = 0;
45012 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45013 wxString *arg2 = 0 ;
45014 int result;
45015 void *argp1 = 0 ;
45016 int res1 = 0 ;
45017 bool temp2 = false ;
45018 PyObject * obj0 = 0 ;
45019 PyObject * obj1 = 0 ;
45020 char * kwnames[] = {
45021 (char *) "self",(char *) "s", NULL
45022 };
45023
45024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45026 if (!SWIG_IsOK(res1)) {
45027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45028 }
45029 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45030 {
45031 arg2 = wxString_in_helper(obj1);
45032 if (arg2 == NULL) SWIG_fail;
45033 temp2 = true;
45034 }
45035 {
45036 PyThreadState* __tstate = wxPyBeginAllowThreads();
45037 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45038 wxPyEndAllowThreads(__tstate);
45039 if (PyErr_Occurred()) SWIG_fail;
45040 }
45041 resultobj = SWIG_From_int(static_cast< int >(result));
45042 {
45043 if (temp2)
45044 delete arg2;
45045 }
45046 return resultobj;
45047 fail:
45048 {
45049 if (temp2)
45050 delete arg2;
45051 }
45052 return NULL;
45053 }
45054
45055
45056 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45057 PyObject *resultobj = 0;
45058 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45059 int arg2 ;
45060 void *argp1 = 0 ;
45061 int res1 = 0 ;
45062 int val2 ;
45063 int ecode2 = 0 ;
45064 PyObject * obj0 = 0 ;
45065 PyObject * obj1 = 0 ;
45066 char * kwnames[] = {
45067 (char *) "self",(char *) "n", NULL
45068 };
45069
45070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45072 if (!SWIG_IsOK(res1)) {
45073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45074 }
45075 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45076 ecode2 = SWIG_AsVal_int(obj1, &val2);
45077 if (!SWIG_IsOK(ecode2)) {
45078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45079 }
45080 arg2 = static_cast< int >(val2);
45081 {
45082 PyThreadState* __tstate = wxPyBeginAllowThreads();
45083 (arg1)->SetSelection(arg2);
45084 wxPyEndAllowThreads(__tstate);
45085 if (PyErr_Occurred()) SWIG_fail;
45086 }
45087 resultobj = SWIG_Py_Void();
45088 return resultobj;
45089 fail:
45090 return NULL;
45091 }
45092
45093
45094 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45095 PyObject *resultobj = 0;
45096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45097 int 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_wxItemContainer, 0 | 0 );
45105 if (!SWIG_IsOK(res1)) {
45106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45107 }
45108 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45109 {
45110 PyThreadState* __tstate = wxPyBeginAllowThreads();
45111 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45112 wxPyEndAllowThreads(__tstate);
45113 if (PyErr_Occurred()) SWIG_fail;
45114 }
45115 resultobj = SWIG_From_int(static_cast< int >(result));
45116 return resultobj;
45117 fail:
45118 return NULL;
45119 }
45120
45121
45122 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45123 PyObject *resultobj = 0;
45124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45125 wxString *arg2 = 0 ;
45126 bool result;
45127 void *argp1 = 0 ;
45128 int res1 = 0 ;
45129 bool temp2 = false ;
45130 PyObject * obj0 = 0 ;
45131 PyObject * obj1 = 0 ;
45132 char * kwnames[] = {
45133 (char *) "self",(char *) "s", NULL
45134 };
45135
45136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45138 if (!SWIG_IsOK(res1)) {
45139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45140 }
45141 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45142 {
45143 arg2 = wxString_in_helper(obj1);
45144 if (arg2 == NULL) SWIG_fail;
45145 temp2 = true;
45146 }
45147 {
45148 PyThreadState* __tstate = wxPyBeginAllowThreads();
45149 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45150 wxPyEndAllowThreads(__tstate);
45151 if (PyErr_Occurred()) SWIG_fail;
45152 }
45153 {
45154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45155 }
45156 {
45157 if (temp2)
45158 delete arg2;
45159 }
45160 return resultobj;
45161 fail:
45162 {
45163 if (temp2)
45164 delete arg2;
45165 }
45166 return NULL;
45167 }
45168
45169
45170 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45171 PyObject *resultobj = 0;
45172 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45173 wxString result;
45174 void *argp1 = 0 ;
45175 int res1 = 0 ;
45176 PyObject *swig_obj[1] ;
45177
45178 if (!args) SWIG_fail;
45179 swig_obj[0] = args;
45180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45181 if (!SWIG_IsOK(res1)) {
45182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45183 }
45184 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45185 {
45186 PyThreadState* __tstate = wxPyBeginAllowThreads();
45187 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45188 wxPyEndAllowThreads(__tstate);
45189 if (PyErr_Occurred()) SWIG_fail;
45190 }
45191 {
45192 #if wxUSE_UNICODE
45193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45194 #else
45195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45196 #endif
45197 }
45198 return resultobj;
45199 fail:
45200 return NULL;
45201 }
45202
45203
45204 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45205 PyObject *resultobj = 0;
45206 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45207 int arg2 ;
45208 void *argp1 = 0 ;
45209 int res1 = 0 ;
45210 int val2 ;
45211 int ecode2 = 0 ;
45212 PyObject * obj0 = 0 ;
45213 PyObject * obj1 = 0 ;
45214 char * kwnames[] = {
45215 (char *) "self",(char *) "n", NULL
45216 };
45217
45218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45220 if (!SWIG_IsOK(res1)) {
45221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45222 }
45223 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45224 ecode2 = SWIG_AsVal_int(obj1, &val2);
45225 if (!SWIG_IsOK(ecode2)) {
45226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45227 }
45228 arg2 = static_cast< int >(val2);
45229 {
45230 PyThreadState* __tstate = wxPyBeginAllowThreads();
45231 (arg1)->Select(arg2);
45232 wxPyEndAllowThreads(__tstate);
45233 if (PyErr_Occurred()) SWIG_fail;
45234 }
45235 resultobj = SWIG_Py_Void();
45236 return resultobj;
45237 fail:
45238 return NULL;
45239 }
45240
45241
45242 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45243 PyObject *obj;
45244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45245 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45246 return SWIG_Py_Void();
45247 }
45248
45249 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45250 PyObject *obj;
45251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45252 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45253 return SWIG_Py_Void();
45254 }
45255
45256 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45257 PyObject *resultobj = 0;
45258 wxSizerItem *result = 0 ;
45259
45260 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 result = (wxSizerItem *)new wxSizerItem();
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45268 return resultobj;
45269 fail:
45270 return NULL;
45271 }
45272
45273
45274 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45275 PyObject *resultobj = 0;
45276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45277 void *argp1 = 0 ;
45278 int res1 = 0 ;
45279 PyObject *swig_obj[1] ;
45280
45281 if (!args) SWIG_fail;
45282 swig_obj[0] = args;
45283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45284 if (!SWIG_IsOK(res1)) {
45285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45286 }
45287 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 delete arg1;
45291
45292 wxPyEndAllowThreads(__tstate);
45293 if (PyErr_Occurred()) SWIG_fail;
45294 }
45295 resultobj = SWIG_Py_Void();
45296 return resultobj;
45297 fail:
45298 return NULL;
45299 }
45300
45301
45302 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45303 PyObject *resultobj = 0;
45304 wxWindow *arg1 = (wxWindow *) 0 ;
45305 int arg2 ;
45306 int arg3 ;
45307 int arg4 ;
45308 PyObject *arg5 = (PyObject *) NULL ;
45309 wxSizerItem *result = 0 ;
45310 void *argp1 = 0 ;
45311 int res1 = 0 ;
45312 int val2 ;
45313 int ecode2 = 0 ;
45314 int val3 ;
45315 int ecode3 = 0 ;
45316 int val4 ;
45317 int ecode4 = 0 ;
45318 PyObject * obj0 = 0 ;
45319 PyObject * obj1 = 0 ;
45320 PyObject * obj2 = 0 ;
45321 PyObject * obj3 = 0 ;
45322 PyObject * obj4 = 0 ;
45323 char * kwnames[] = {
45324 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45325 };
45326
45327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45329 if (!SWIG_IsOK(res1)) {
45330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45331 }
45332 arg1 = reinterpret_cast< wxWindow * >(argp1);
45333 ecode2 = SWIG_AsVal_int(obj1, &val2);
45334 if (!SWIG_IsOK(ecode2)) {
45335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45336 }
45337 arg2 = static_cast< int >(val2);
45338 ecode3 = SWIG_AsVal_int(obj2, &val3);
45339 if (!SWIG_IsOK(ecode3)) {
45340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45341 }
45342 arg3 = static_cast< int >(val3);
45343 ecode4 = SWIG_AsVal_int(obj3, &val4);
45344 if (!SWIG_IsOK(ecode4)) {
45345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45346 }
45347 arg4 = static_cast< int >(val4);
45348 if (obj4) {
45349 arg5 = obj4;
45350 }
45351 {
45352 PyThreadState* __tstate = wxPyBeginAllowThreads();
45353 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45354 wxPyEndAllowThreads(__tstate);
45355 if (PyErr_Occurred()) SWIG_fail;
45356 }
45357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45358 return resultobj;
45359 fail:
45360 return NULL;
45361 }
45362
45363
45364 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45365 PyObject *resultobj = 0;
45366 int arg1 ;
45367 int arg2 ;
45368 int arg3 ;
45369 int arg4 ;
45370 int arg5 ;
45371 PyObject *arg6 = (PyObject *) NULL ;
45372 wxSizerItem *result = 0 ;
45373 int val1 ;
45374 int ecode1 = 0 ;
45375 int val2 ;
45376 int ecode2 = 0 ;
45377 int val3 ;
45378 int ecode3 = 0 ;
45379 int val4 ;
45380 int ecode4 = 0 ;
45381 int val5 ;
45382 int ecode5 = 0 ;
45383 PyObject * obj0 = 0 ;
45384 PyObject * obj1 = 0 ;
45385 PyObject * obj2 = 0 ;
45386 PyObject * obj3 = 0 ;
45387 PyObject * obj4 = 0 ;
45388 PyObject * obj5 = 0 ;
45389 char * kwnames[] = {
45390 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45391 };
45392
45393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45394 ecode1 = SWIG_AsVal_int(obj0, &val1);
45395 if (!SWIG_IsOK(ecode1)) {
45396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45397 }
45398 arg1 = static_cast< int >(val1);
45399 ecode2 = SWIG_AsVal_int(obj1, &val2);
45400 if (!SWIG_IsOK(ecode2)) {
45401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45402 }
45403 arg2 = static_cast< int >(val2);
45404 ecode3 = SWIG_AsVal_int(obj2, &val3);
45405 if (!SWIG_IsOK(ecode3)) {
45406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45407 }
45408 arg3 = static_cast< int >(val3);
45409 ecode4 = SWIG_AsVal_int(obj3, &val4);
45410 if (!SWIG_IsOK(ecode4)) {
45411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45412 }
45413 arg4 = static_cast< int >(val4);
45414 ecode5 = SWIG_AsVal_int(obj4, &val5);
45415 if (!SWIG_IsOK(ecode5)) {
45416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45417 }
45418 arg5 = static_cast< int >(val5);
45419 if (obj5) {
45420 arg6 = obj5;
45421 }
45422 {
45423 PyThreadState* __tstate = wxPyBeginAllowThreads();
45424 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45425 wxPyEndAllowThreads(__tstate);
45426 if (PyErr_Occurred()) SWIG_fail;
45427 }
45428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45429 return resultobj;
45430 fail:
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj = 0;
45437 wxSizer *arg1 = (wxSizer *) 0 ;
45438 int arg2 ;
45439 int arg3 ;
45440 int arg4 ;
45441 PyObject *arg5 = (PyObject *) NULL ;
45442 wxSizerItem *result = 0 ;
45443 int res1 = 0 ;
45444 int val2 ;
45445 int ecode2 = 0 ;
45446 int val3 ;
45447 int ecode3 = 0 ;
45448 int val4 ;
45449 int ecode4 = 0 ;
45450 PyObject * obj0 = 0 ;
45451 PyObject * obj1 = 0 ;
45452 PyObject * obj2 = 0 ;
45453 PyObject * obj3 = 0 ;
45454 PyObject * obj4 = 0 ;
45455 char * kwnames[] = {
45456 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45457 };
45458
45459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45460 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45461 if (!SWIG_IsOK(res1)) {
45462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45463 }
45464 ecode2 = SWIG_AsVal_int(obj1, &val2);
45465 if (!SWIG_IsOK(ecode2)) {
45466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45467 }
45468 arg2 = static_cast< int >(val2);
45469 ecode3 = SWIG_AsVal_int(obj2, &val3);
45470 if (!SWIG_IsOK(ecode3)) {
45471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45472 }
45473 arg3 = static_cast< int >(val3);
45474 ecode4 = SWIG_AsVal_int(obj3, &val4);
45475 if (!SWIG_IsOK(ecode4)) {
45476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45477 }
45478 arg4 = static_cast< int >(val4);
45479 if (obj4) {
45480 arg5 = obj4;
45481 }
45482 {
45483 PyThreadState* __tstate = wxPyBeginAllowThreads();
45484 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45485 wxPyEndAllowThreads(__tstate);
45486 if (PyErr_Occurred()) SWIG_fail;
45487 }
45488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45489 return resultobj;
45490 fail:
45491 return NULL;
45492 }
45493
45494
45495 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45496 PyObject *resultobj = 0;
45497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 PyObject *swig_obj[1] ;
45501
45502 if (!args) SWIG_fail;
45503 swig_obj[0] = args;
45504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45505 if (!SWIG_IsOK(res1)) {
45506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45507 }
45508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 (arg1)->DeleteWindows();
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 resultobj = SWIG_Py_Void();
45516 return resultobj;
45517 fail:
45518 return NULL;
45519 }
45520
45521
45522 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45523 PyObject *resultobj = 0;
45524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45525 void *argp1 = 0 ;
45526 int res1 = 0 ;
45527 PyObject *swig_obj[1] ;
45528
45529 if (!args) SWIG_fail;
45530 swig_obj[0] = args;
45531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45532 if (!SWIG_IsOK(res1)) {
45533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45534 }
45535 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45536 {
45537 PyThreadState* __tstate = wxPyBeginAllowThreads();
45538 (arg1)->DetachSizer();
45539 wxPyEndAllowThreads(__tstate);
45540 if (PyErr_Occurred()) SWIG_fail;
45541 }
45542 resultobj = SWIG_Py_Void();
45543 return resultobj;
45544 fail:
45545 return NULL;
45546 }
45547
45548
45549 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45550 PyObject *resultobj = 0;
45551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45552 wxSize result;
45553 void *argp1 = 0 ;
45554 int res1 = 0 ;
45555 PyObject *swig_obj[1] ;
45556
45557 if (!args) SWIG_fail;
45558 swig_obj[0] = args;
45559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45560 if (!SWIG_IsOK(res1)) {
45561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45562 }
45563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 result = (arg1)->GetSize();
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45571 return resultobj;
45572 fail:
45573 return NULL;
45574 }
45575
45576
45577 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45578 PyObject *resultobj = 0;
45579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45580 wxSize result;
45581 void *argp1 = 0 ;
45582 int res1 = 0 ;
45583 PyObject *swig_obj[1] ;
45584
45585 if (!args) SWIG_fail;
45586 swig_obj[0] = args;
45587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45588 if (!SWIG_IsOK(res1)) {
45589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45590 }
45591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45592 {
45593 PyThreadState* __tstate = wxPyBeginAllowThreads();
45594 result = (arg1)->CalcMin();
45595 wxPyEndAllowThreads(__tstate);
45596 if (PyErr_Occurred()) SWIG_fail;
45597 }
45598 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45599 return resultobj;
45600 fail:
45601 return NULL;
45602 }
45603
45604
45605 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45606 PyObject *resultobj = 0;
45607 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45608 wxPoint *arg2 = 0 ;
45609 wxSize *arg3 = 0 ;
45610 void *argp1 = 0 ;
45611 int res1 = 0 ;
45612 wxPoint temp2 ;
45613 wxSize temp3 ;
45614 PyObject * obj0 = 0 ;
45615 PyObject * obj1 = 0 ;
45616 PyObject * obj2 = 0 ;
45617 char * kwnames[] = {
45618 (char *) "self",(char *) "pos",(char *) "size", NULL
45619 };
45620
45621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45623 if (!SWIG_IsOK(res1)) {
45624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45625 }
45626 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45627 {
45628 arg2 = &temp2;
45629 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45630 }
45631 {
45632 arg3 = &temp3;
45633 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45634 }
45635 {
45636 PyThreadState* __tstate = wxPyBeginAllowThreads();
45637 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45638 wxPyEndAllowThreads(__tstate);
45639 if (PyErr_Occurred()) SWIG_fail;
45640 }
45641 resultobj = SWIG_Py_Void();
45642 return resultobj;
45643 fail:
45644 return NULL;
45645 }
45646
45647
45648 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45649 PyObject *resultobj = 0;
45650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45651 wxSize result;
45652 void *argp1 = 0 ;
45653 int res1 = 0 ;
45654 PyObject *swig_obj[1] ;
45655
45656 if (!args) SWIG_fail;
45657 swig_obj[0] = args;
45658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45659 if (!SWIG_IsOK(res1)) {
45660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45661 }
45662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (arg1)->GetMinSize();
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45677 PyObject *resultobj = 0;
45678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45679 wxSize result;
45680 void *argp1 = 0 ;
45681 int res1 = 0 ;
45682 PyObject *swig_obj[1] ;
45683
45684 if (!args) SWIG_fail;
45685 swig_obj[0] = args;
45686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45687 if (!SWIG_IsOK(res1)) {
45688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45689 }
45690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45691 {
45692 PyThreadState* __tstate = wxPyBeginAllowThreads();
45693 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45694 wxPyEndAllowThreads(__tstate);
45695 if (PyErr_Occurred()) SWIG_fail;
45696 }
45697 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45698 return resultobj;
45699 fail:
45700 return NULL;
45701 }
45702
45703
45704 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45705 PyObject *resultobj = 0;
45706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45707 int arg2 ;
45708 int arg3 ;
45709 void *argp1 = 0 ;
45710 int res1 = 0 ;
45711 int val2 ;
45712 int ecode2 = 0 ;
45713 int val3 ;
45714 int ecode3 = 0 ;
45715 PyObject * obj0 = 0 ;
45716 PyObject * obj1 = 0 ;
45717 PyObject * obj2 = 0 ;
45718 char * kwnames[] = {
45719 (char *) "self",(char *) "x",(char *) "y", NULL
45720 };
45721
45722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45724 if (!SWIG_IsOK(res1)) {
45725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45726 }
45727 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45728 ecode2 = SWIG_AsVal_int(obj1, &val2);
45729 if (!SWIG_IsOK(ecode2)) {
45730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45731 }
45732 arg2 = static_cast< int >(val2);
45733 ecode3 = SWIG_AsVal_int(obj2, &val3);
45734 if (!SWIG_IsOK(ecode3)) {
45735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45736 }
45737 arg3 = static_cast< int >(val3);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 (arg1)->SetInitSize(arg2,arg3);
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 resultobj = SWIG_Py_Void();
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj = 0;
45753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45754 int arg2 ;
45755 int arg3 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 int val2 ;
45759 int ecode2 = 0 ;
45760 int val3 ;
45761 int ecode3 = 0 ;
45762 PyObject * obj0 = 0 ;
45763 PyObject * obj1 = 0 ;
45764 PyObject * obj2 = 0 ;
45765 char * kwnames[] = {
45766 (char *) "self",(char *) "width",(char *) "height", NULL
45767 };
45768
45769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45771 if (!SWIG_IsOK(res1)) {
45772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45773 }
45774 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45775 ecode2 = SWIG_AsVal_int(obj1, &val2);
45776 if (!SWIG_IsOK(ecode2)) {
45777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45778 }
45779 arg2 = static_cast< int >(val2);
45780 ecode3 = SWIG_AsVal_int(obj2, &val3);
45781 if (!SWIG_IsOK(ecode3)) {
45782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45783 }
45784 arg3 = static_cast< int >(val3);
45785 {
45786 PyThreadState* __tstate = wxPyBeginAllowThreads();
45787 (arg1)->SetRatio(arg2,arg3);
45788 wxPyEndAllowThreads(__tstate);
45789 if (PyErr_Occurred()) SWIG_fail;
45790 }
45791 resultobj = SWIG_Py_Void();
45792 return resultobj;
45793 fail:
45794 return NULL;
45795 }
45796
45797
45798 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45799 PyObject *resultobj = 0;
45800 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45801 wxSize *arg2 = 0 ;
45802 void *argp1 = 0 ;
45803 int res1 = 0 ;
45804 wxSize temp2 ;
45805 PyObject * obj0 = 0 ;
45806 PyObject * obj1 = 0 ;
45807 char * kwnames[] = {
45808 (char *) "self",(char *) "size", NULL
45809 };
45810
45811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45813 if (!SWIG_IsOK(res1)) {
45814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45815 }
45816 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45817 {
45818 arg2 = &temp2;
45819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45820 }
45821 {
45822 PyThreadState* __tstate = wxPyBeginAllowThreads();
45823 (arg1)->SetRatio((wxSize const &)*arg2);
45824 wxPyEndAllowThreads(__tstate);
45825 if (PyErr_Occurred()) SWIG_fail;
45826 }
45827 resultobj = SWIG_Py_Void();
45828 return resultobj;
45829 fail:
45830 return NULL;
45831 }
45832
45833
45834 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45835 PyObject *resultobj = 0;
45836 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45837 float arg2 ;
45838 void *argp1 = 0 ;
45839 int res1 = 0 ;
45840 float val2 ;
45841 int ecode2 = 0 ;
45842 PyObject * obj0 = 0 ;
45843 PyObject * obj1 = 0 ;
45844 char * kwnames[] = {
45845 (char *) "self",(char *) "ratio", NULL
45846 };
45847
45848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45850 if (!SWIG_IsOK(res1)) {
45851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45852 }
45853 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45854 ecode2 = SWIG_AsVal_float(obj1, &val2);
45855 if (!SWIG_IsOK(ecode2)) {
45856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45857 }
45858 arg2 = static_cast< float >(val2);
45859 {
45860 PyThreadState* __tstate = wxPyBeginAllowThreads();
45861 (arg1)->SetRatio(arg2);
45862 wxPyEndAllowThreads(__tstate);
45863 if (PyErr_Occurred()) SWIG_fail;
45864 }
45865 resultobj = SWIG_Py_Void();
45866 return resultobj;
45867 fail:
45868 return NULL;
45869 }
45870
45871
45872 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45873 PyObject *resultobj = 0;
45874 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45875 float result;
45876 void *argp1 = 0 ;
45877 int res1 = 0 ;
45878 PyObject *swig_obj[1] ;
45879
45880 if (!args) SWIG_fail;
45881 swig_obj[0] = args;
45882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45883 if (!SWIG_IsOK(res1)) {
45884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45885 }
45886 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45887 {
45888 PyThreadState* __tstate = wxPyBeginAllowThreads();
45889 result = (float)(arg1)->GetRatio();
45890 wxPyEndAllowThreads(__tstate);
45891 if (PyErr_Occurred()) SWIG_fail;
45892 }
45893 resultobj = SWIG_From_float(static_cast< float >(result));
45894 return resultobj;
45895 fail:
45896 return NULL;
45897 }
45898
45899
45900 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45901 PyObject *resultobj = 0;
45902 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45903 wxRect result;
45904 void *argp1 = 0 ;
45905 int res1 = 0 ;
45906 PyObject *swig_obj[1] ;
45907
45908 if (!args) SWIG_fail;
45909 swig_obj[0] = args;
45910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45911 if (!SWIG_IsOK(res1)) {
45912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45913 }
45914 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45915 {
45916 PyThreadState* __tstate = wxPyBeginAllowThreads();
45917 result = (arg1)->GetRect();
45918 wxPyEndAllowThreads(__tstate);
45919 if (PyErr_Occurred()) SWIG_fail;
45920 }
45921 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45929 PyObject *resultobj = 0;
45930 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45931 bool result;
45932 void *argp1 = 0 ;
45933 int res1 = 0 ;
45934 PyObject *swig_obj[1] ;
45935
45936 if (!args) SWIG_fail;
45937 swig_obj[0] = args;
45938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45939 if (!SWIG_IsOK(res1)) {
45940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45941 }
45942 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45943 {
45944 PyThreadState* __tstate = wxPyBeginAllowThreads();
45945 result = (bool)(arg1)->IsWindow();
45946 wxPyEndAllowThreads(__tstate);
45947 if (PyErr_Occurred()) SWIG_fail;
45948 }
45949 {
45950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45951 }
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45961 bool result;
45962 void *argp1 = 0 ;
45963 int res1 = 0 ;
45964 PyObject *swig_obj[1] ;
45965
45966 if (!args) SWIG_fail;
45967 swig_obj[0] = args;
45968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45969 if (!SWIG_IsOK(res1)) {
45970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45971 }
45972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 result = (bool)(arg1)->IsSizer();
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 {
45980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45981 }
45982 return resultobj;
45983 fail:
45984 return NULL;
45985 }
45986
45987
45988 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45989 PyObject *resultobj = 0;
45990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45991 bool result;
45992 void *argp1 = 0 ;
45993 int res1 = 0 ;
45994 PyObject *swig_obj[1] ;
45995
45996 if (!args) SWIG_fail;
45997 swig_obj[0] = args;
45998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45999 if (!SWIG_IsOK(res1)) {
46000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46001 }
46002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46003 {
46004 PyThreadState* __tstate = wxPyBeginAllowThreads();
46005 result = (bool)(arg1)->IsSpacer();
46006 wxPyEndAllowThreads(__tstate);
46007 if (PyErr_Occurred()) SWIG_fail;
46008 }
46009 {
46010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46011 }
46012 return resultobj;
46013 fail:
46014 return NULL;
46015 }
46016
46017
46018 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46019 PyObject *resultobj = 0;
46020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46021 int arg2 ;
46022 void *argp1 = 0 ;
46023 int res1 = 0 ;
46024 int val2 ;
46025 int ecode2 = 0 ;
46026 PyObject * obj0 = 0 ;
46027 PyObject * obj1 = 0 ;
46028 char * kwnames[] = {
46029 (char *) "self",(char *) "proportion", NULL
46030 };
46031
46032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46034 if (!SWIG_IsOK(res1)) {
46035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46036 }
46037 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46038 ecode2 = SWIG_AsVal_int(obj1, &val2);
46039 if (!SWIG_IsOK(ecode2)) {
46040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46041 }
46042 arg2 = static_cast< int >(val2);
46043 {
46044 PyThreadState* __tstate = wxPyBeginAllowThreads();
46045 (arg1)->SetProportion(arg2);
46046 wxPyEndAllowThreads(__tstate);
46047 if (PyErr_Occurred()) SWIG_fail;
46048 }
46049 resultobj = SWIG_Py_Void();
46050 return resultobj;
46051 fail:
46052 return NULL;
46053 }
46054
46055
46056 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46057 PyObject *resultobj = 0;
46058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46059 int result;
46060 void *argp1 = 0 ;
46061 int res1 = 0 ;
46062 PyObject *swig_obj[1] ;
46063
46064 if (!args) SWIG_fail;
46065 swig_obj[0] = args;
46066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46067 if (!SWIG_IsOK(res1)) {
46068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46069 }
46070 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46071 {
46072 PyThreadState* __tstate = wxPyBeginAllowThreads();
46073 result = (int)(arg1)->GetProportion();
46074 wxPyEndAllowThreads(__tstate);
46075 if (PyErr_Occurred()) SWIG_fail;
46076 }
46077 resultobj = SWIG_From_int(static_cast< int >(result));
46078 return resultobj;
46079 fail:
46080 return NULL;
46081 }
46082
46083
46084 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46085 PyObject *resultobj = 0;
46086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46087 int arg2 ;
46088 void *argp1 = 0 ;
46089 int res1 = 0 ;
46090 int val2 ;
46091 int ecode2 = 0 ;
46092 PyObject * obj0 = 0 ;
46093 PyObject * obj1 = 0 ;
46094 char * kwnames[] = {
46095 (char *) "self",(char *) "flag", NULL
46096 };
46097
46098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46100 if (!SWIG_IsOK(res1)) {
46101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46102 }
46103 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46104 ecode2 = SWIG_AsVal_int(obj1, &val2);
46105 if (!SWIG_IsOK(ecode2)) {
46106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46107 }
46108 arg2 = static_cast< int >(val2);
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 (arg1)->SetFlag(arg2);
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_Py_Void();
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46123 PyObject *resultobj = 0;
46124 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46125 int result;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 PyObject *swig_obj[1] ;
46129
46130 if (!args) SWIG_fail;
46131 swig_obj[0] = args;
46132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46135 }
46136 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 result = (int)(arg1)->GetFlag();
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_From_int(static_cast< int >(result));
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46153 int arg2 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 int val2 ;
46157 int ecode2 = 0 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "border", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46168 }
46169 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46170 ecode2 = SWIG_AsVal_int(obj1, &val2);
46171 if (!SWIG_IsOK(ecode2)) {
46172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46173 }
46174 arg2 = static_cast< int >(val2);
46175 {
46176 PyThreadState* __tstate = wxPyBeginAllowThreads();
46177 (arg1)->SetBorder(arg2);
46178 wxPyEndAllowThreads(__tstate);
46179 if (PyErr_Occurred()) SWIG_fail;
46180 }
46181 resultobj = SWIG_Py_Void();
46182 return resultobj;
46183 fail:
46184 return NULL;
46185 }
46186
46187
46188 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46189 PyObject *resultobj = 0;
46190 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46191 int result;
46192 void *argp1 = 0 ;
46193 int res1 = 0 ;
46194 PyObject *swig_obj[1] ;
46195
46196 if (!args) SWIG_fail;
46197 swig_obj[0] = args;
46198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46199 if (!SWIG_IsOK(res1)) {
46200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46201 }
46202 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46203 {
46204 PyThreadState* __tstate = wxPyBeginAllowThreads();
46205 result = (int)(arg1)->GetBorder();
46206 wxPyEndAllowThreads(__tstate);
46207 if (PyErr_Occurred()) SWIG_fail;
46208 }
46209 resultobj = SWIG_From_int(static_cast< int >(result));
46210 return resultobj;
46211 fail:
46212 return NULL;
46213 }
46214
46215
46216 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46217 PyObject *resultobj = 0;
46218 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46219 wxWindow *result = 0 ;
46220 void *argp1 = 0 ;
46221 int res1 = 0 ;
46222 PyObject *swig_obj[1] ;
46223
46224 if (!args) SWIG_fail;
46225 swig_obj[0] = args;
46226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46227 if (!SWIG_IsOK(res1)) {
46228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46229 }
46230 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46231 {
46232 PyThreadState* __tstate = wxPyBeginAllowThreads();
46233 result = (wxWindow *)(arg1)->GetWindow();
46234 wxPyEndAllowThreads(__tstate);
46235 if (PyErr_Occurred()) SWIG_fail;
46236 }
46237 {
46238 resultobj = wxPyMake_wxObject(result, 0);
46239 }
46240 return resultobj;
46241 fail:
46242 return NULL;
46243 }
46244
46245
46246 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46247 PyObject *resultobj = 0;
46248 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46249 wxWindow *arg2 = (wxWindow *) 0 ;
46250 void *argp1 = 0 ;
46251 int res1 = 0 ;
46252 void *argp2 = 0 ;
46253 int res2 = 0 ;
46254 PyObject * obj0 = 0 ;
46255 PyObject * obj1 = 0 ;
46256 char * kwnames[] = {
46257 (char *) "self",(char *) "window", NULL
46258 };
46259
46260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46262 if (!SWIG_IsOK(res1)) {
46263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46264 }
46265 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46267 if (!SWIG_IsOK(res2)) {
46268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46269 }
46270 arg2 = reinterpret_cast< wxWindow * >(argp2);
46271 {
46272 PyThreadState* __tstate = wxPyBeginAllowThreads();
46273 (arg1)->SetWindow(arg2);
46274 wxPyEndAllowThreads(__tstate);
46275 if (PyErr_Occurred()) SWIG_fail;
46276 }
46277 resultobj = SWIG_Py_Void();
46278 return resultobj;
46279 fail:
46280 return NULL;
46281 }
46282
46283
46284 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46285 PyObject *resultobj = 0;
46286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46287 wxSizer *result = 0 ;
46288 void *argp1 = 0 ;
46289 int res1 = 0 ;
46290 PyObject *swig_obj[1] ;
46291
46292 if (!args) SWIG_fail;
46293 swig_obj[0] = args;
46294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46295 if (!SWIG_IsOK(res1)) {
46296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46297 }
46298 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46299 {
46300 PyThreadState* __tstate = wxPyBeginAllowThreads();
46301 result = (wxSizer *)(arg1)->GetSizer();
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 {
46306 resultobj = wxPyMake_wxObject(result, (bool)0);
46307 }
46308 return resultobj;
46309 fail:
46310 return NULL;
46311 }
46312
46313
46314 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46315 PyObject *resultobj = 0;
46316 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46317 wxSizer *arg2 = (wxSizer *) 0 ;
46318 void *argp1 = 0 ;
46319 int res1 = 0 ;
46320 int res2 = 0 ;
46321 PyObject * obj0 = 0 ;
46322 PyObject * obj1 = 0 ;
46323 char * kwnames[] = {
46324 (char *) "self",(char *) "sizer", NULL
46325 };
46326
46327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46329 if (!SWIG_IsOK(res1)) {
46330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46331 }
46332 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46333 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46334 if (!SWIG_IsOK(res2)) {
46335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46336 }
46337 {
46338 PyThreadState* __tstate = wxPyBeginAllowThreads();
46339 (arg1)->SetSizer(arg2);
46340 wxPyEndAllowThreads(__tstate);
46341 if (PyErr_Occurred()) SWIG_fail;
46342 }
46343 resultobj = SWIG_Py_Void();
46344 return resultobj;
46345 fail:
46346 return NULL;
46347 }
46348
46349
46350 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46351 PyObject *resultobj = 0;
46352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46353 wxSize *result = 0 ;
46354 void *argp1 = 0 ;
46355 int res1 = 0 ;
46356 PyObject *swig_obj[1] ;
46357
46358 if (!args) SWIG_fail;
46359 swig_obj[0] = args;
46360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46361 if (!SWIG_IsOK(res1)) {
46362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46363 }
46364 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46365 {
46366 PyThreadState* __tstate = wxPyBeginAllowThreads();
46367 {
46368 wxSize const &_result_ref = (arg1)->GetSpacer();
46369 result = (wxSize *) &_result_ref;
46370 }
46371 wxPyEndAllowThreads(__tstate);
46372 if (PyErr_Occurred()) SWIG_fail;
46373 }
46374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46375 return resultobj;
46376 fail:
46377 return NULL;
46378 }
46379
46380
46381 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46382 PyObject *resultobj = 0;
46383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46384 wxSize *arg2 = 0 ;
46385 void *argp1 = 0 ;
46386 int res1 = 0 ;
46387 wxSize temp2 ;
46388 PyObject * obj0 = 0 ;
46389 PyObject * obj1 = 0 ;
46390 char * kwnames[] = {
46391 (char *) "self",(char *) "size", NULL
46392 };
46393
46394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46396 if (!SWIG_IsOK(res1)) {
46397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46398 }
46399 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46400 {
46401 arg2 = &temp2;
46402 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46403 }
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 (arg1)->SetSpacer((wxSize const &)*arg2);
46407 wxPyEndAllowThreads(__tstate);
46408 if (PyErr_Occurred()) SWIG_fail;
46409 }
46410 resultobj = SWIG_Py_Void();
46411 return resultobj;
46412 fail:
46413 return NULL;
46414 }
46415
46416
46417 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46418 PyObject *resultobj = 0;
46419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46420 bool arg2 ;
46421 void *argp1 = 0 ;
46422 int res1 = 0 ;
46423 bool val2 ;
46424 int ecode2 = 0 ;
46425 PyObject * obj0 = 0 ;
46426 PyObject * obj1 = 0 ;
46427 char * kwnames[] = {
46428 (char *) "self",(char *) "show", NULL
46429 };
46430
46431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46433 if (!SWIG_IsOK(res1)) {
46434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46435 }
46436 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46438 if (!SWIG_IsOK(ecode2)) {
46439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46440 }
46441 arg2 = static_cast< bool >(val2);
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 (arg1)->Show(arg2);
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 resultobj = SWIG_Py_Void();
46449 return resultobj;
46450 fail:
46451 return NULL;
46452 }
46453
46454
46455 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46456 PyObject *resultobj = 0;
46457 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46458 bool result;
46459 void *argp1 = 0 ;
46460 int res1 = 0 ;
46461 PyObject *swig_obj[1] ;
46462
46463 if (!args) SWIG_fail;
46464 swig_obj[0] = args;
46465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46466 if (!SWIG_IsOK(res1)) {
46467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46468 }
46469 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46470 {
46471 PyThreadState* __tstate = wxPyBeginAllowThreads();
46472 result = (bool)(arg1)->IsShown();
46473 wxPyEndAllowThreads(__tstate);
46474 if (PyErr_Occurred()) SWIG_fail;
46475 }
46476 {
46477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46478 }
46479 return resultobj;
46480 fail:
46481 return NULL;
46482 }
46483
46484
46485 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46486 PyObject *resultobj = 0;
46487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46488 wxPoint result;
46489 void *argp1 = 0 ;
46490 int res1 = 0 ;
46491 PyObject *swig_obj[1] ;
46492
46493 if (!args) SWIG_fail;
46494 swig_obj[0] = args;
46495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46496 if (!SWIG_IsOK(res1)) {
46497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46498 }
46499 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46500 {
46501 PyThreadState* __tstate = wxPyBeginAllowThreads();
46502 result = (arg1)->GetPosition();
46503 wxPyEndAllowThreads(__tstate);
46504 if (PyErr_Occurred()) SWIG_fail;
46505 }
46506 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46507 return resultobj;
46508 fail:
46509 return NULL;
46510 }
46511
46512
46513 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46514 PyObject *resultobj = 0;
46515 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46516 PyObject *result = 0 ;
46517 void *argp1 = 0 ;
46518 int res1 = 0 ;
46519 PyObject *swig_obj[1] ;
46520
46521 if (!args) SWIG_fail;
46522 swig_obj[0] = args;
46523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46524 if (!SWIG_IsOK(res1)) {
46525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46526 }
46527 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46528 {
46529 PyThreadState* __tstate = wxPyBeginAllowThreads();
46530 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46531 wxPyEndAllowThreads(__tstate);
46532 if (PyErr_Occurred()) SWIG_fail;
46533 }
46534 resultobj = result;
46535 return resultobj;
46536 fail:
46537 return NULL;
46538 }
46539
46540
46541 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46542 PyObject *resultobj = 0;
46543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46544 PyObject *arg2 = (PyObject *) 0 ;
46545 void *argp1 = 0 ;
46546 int res1 = 0 ;
46547 PyObject * obj0 = 0 ;
46548 PyObject * obj1 = 0 ;
46549 char * kwnames[] = {
46550 (char *) "self",(char *) "userData", NULL
46551 };
46552
46553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46555 if (!SWIG_IsOK(res1)) {
46556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46557 }
46558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46559 arg2 = obj1;
46560 {
46561 PyThreadState* __tstate = wxPyBeginAllowThreads();
46562 wxSizerItem_SetUserData(arg1,arg2);
46563 wxPyEndAllowThreads(__tstate);
46564 if (PyErr_Occurred()) SWIG_fail;
46565 }
46566 resultobj = SWIG_Py_Void();
46567 return resultobj;
46568 fail:
46569 return NULL;
46570 }
46571
46572
46573 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46574 PyObject *obj;
46575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46577 return SWIG_Py_Void();
46578 }
46579
46580 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46581 return SWIG_Python_InitShadowInstance(args);
46582 }
46583
46584 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46585 PyObject *resultobj = 0;
46586 wxSizer *arg1 = (wxSizer *) 0 ;
46587 void *argp1 = 0 ;
46588 int res1 = 0 ;
46589 PyObject *swig_obj[1] ;
46590
46591 if (!args) SWIG_fail;
46592 swig_obj[0] = args;
46593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 {
46599 PyThreadState* __tstate = wxPyBeginAllowThreads();
46600 delete arg1;
46601
46602 wxPyEndAllowThreads(__tstate);
46603 if (PyErr_Occurred()) SWIG_fail;
46604 }
46605 resultobj = SWIG_Py_Void();
46606 return resultobj;
46607 fail:
46608 return NULL;
46609 }
46610
46611
46612 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46613 PyObject *resultobj = 0;
46614 wxSizer *arg1 = (wxSizer *) 0 ;
46615 PyObject *arg2 = (PyObject *) 0 ;
46616 void *argp1 = 0 ;
46617 int res1 = 0 ;
46618 PyObject * obj0 = 0 ;
46619 PyObject * obj1 = 0 ;
46620 char * kwnames[] = {
46621 (char *) "self",(char *) "_self", NULL
46622 };
46623
46624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46626 if (!SWIG_IsOK(res1)) {
46627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46628 }
46629 arg1 = reinterpret_cast< wxSizer * >(argp1);
46630 arg2 = obj1;
46631 {
46632 PyThreadState* __tstate = wxPyBeginAllowThreads();
46633 wxSizer__setOORInfo(arg1,arg2);
46634 wxPyEndAllowThreads(__tstate);
46635 if (PyErr_Occurred()) SWIG_fail;
46636 }
46637 resultobj = SWIG_Py_Void();
46638 return resultobj;
46639 fail:
46640 return NULL;
46641 }
46642
46643
46644 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46645 PyObject *resultobj = 0;
46646 wxSizer *arg1 = (wxSizer *) 0 ;
46647 PyObject *arg2 = (PyObject *) 0 ;
46648 int arg3 = (int) 0 ;
46649 int arg4 = (int) 0 ;
46650 int arg5 = (int) 0 ;
46651 PyObject *arg6 = (PyObject *) NULL ;
46652 wxSizerItem *result = 0 ;
46653 void *argp1 = 0 ;
46654 int res1 = 0 ;
46655 int val3 ;
46656 int ecode3 = 0 ;
46657 int val4 ;
46658 int ecode4 = 0 ;
46659 int val5 ;
46660 int ecode5 = 0 ;
46661 PyObject * obj0 = 0 ;
46662 PyObject * obj1 = 0 ;
46663 PyObject * obj2 = 0 ;
46664 PyObject * obj3 = 0 ;
46665 PyObject * obj4 = 0 ;
46666 PyObject * obj5 = 0 ;
46667 char * kwnames[] = {
46668 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46669 };
46670
46671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46673 if (!SWIG_IsOK(res1)) {
46674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46675 }
46676 arg1 = reinterpret_cast< wxSizer * >(argp1);
46677 arg2 = obj1;
46678 if (obj2) {
46679 ecode3 = SWIG_AsVal_int(obj2, &val3);
46680 if (!SWIG_IsOK(ecode3)) {
46681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46682 }
46683 arg3 = static_cast< int >(val3);
46684 }
46685 if (obj3) {
46686 ecode4 = SWIG_AsVal_int(obj3, &val4);
46687 if (!SWIG_IsOK(ecode4)) {
46688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46689 }
46690 arg4 = static_cast< int >(val4);
46691 }
46692 if (obj4) {
46693 ecode5 = SWIG_AsVal_int(obj4, &val5);
46694 if (!SWIG_IsOK(ecode5)) {
46695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46696 }
46697 arg5 = static_cast< int >(val5);
46698 }
46699 if (obj5) {
46700 arg6 = obj5;
46701 }
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
46704 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46705 wxPyEndAllowThreads(__tstate);
46706 if (PyErr_Occurred()) SWIG_fail;
46707 }
46708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46709 return resultobj;
46710 fail:
46711 return NULL;
46712 }
46713
46714
46715 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46716 PyObject *resultobj = 0;
46717 wxSizer *arg1 = (wxSizer *) 0 ;
46718 int arg2 ;
46719 PyObject *arg3 = (PyObject *) 0 ;
46720 int arg4 = (int) 0 ;
46721 int arg5 = (int) 0 ;
46722 int arg6 = (int) 0 ;
46723 PyObject *arg7 = (PyObject *) NULL ;
46724 wxSizerItem *result = 0 ;
46725 void *argp1 = 0 ;
46726 int res1 = 0 ;
46727 int val2 ;
46728 int ecode2 = 0 ;
46729 int val4 ;
46730 int ecode4 = 0 ;
46731 int val5 ;
46732 int ecode5 = 0 ;
46733 int val6 ;
46734 int ecode6 = 0 ;
46735 PyObject * obj0 = 0 ;
46736 PyObject * obj1 = 0 ;
46737 PyObject * obj2 = 0 ;
46738 PyObject * obj3 = 0 ;
46739 PyObject * obj4 = 0 ;
46740 PyObject * obj5 = 0 ;
46741 PyObject * obj6 = 0 ;
46742 char * kwnames[] = {
46743 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46744 };
46745
46746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46748 if (!SWIG_IsOK(res1)) {
46749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46750 }
46751 arg1 = reinterpret_cast< wxSizer * >(argp1);
46752 ecode2 = SWIG_AsVal_int(obj1, &val2);
46753 if (!SWIG_IsOK(ecode2)) {
46754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46755 }
46756 arg2 = static_cast< int >(val2);
46757 arg3 = obj2;
46758 if (obj3) {
46759 ecode4 = SWIG_AsVal_int(obj3, &val4);
46760 if (!SWIG_IsOK(ecode4)) {
46761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46762 }
46763 arg4 = static_cast< int >(val4);
46764 }
46765 if (obj4) {
46766 ecode5 = SWIG_AsVal_int(obj4, &val5);
46767 if (!SWIG_IsOK(ecode5)) {
46768 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46769 }
46770 arg5 = static_cast< int >(val5);
46771 }
46772 if (obj5) {
46773 ecode6 = SWIG_AsVal_int(obj5, &val6);
46774 if (!SWIG_IsOK(ecode6)) {
46775 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46776 }
46777 arg6 = static_cast< int >(val6);
46778 }
46779 if (obj6) {
46780 arg7 = obj6;
46781 }
46782 {
46783 PyThreadState* __tstate = wxPyBeginAllowThreads();
46784 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46785 wxPyEndAllowThreads(__tstate);
46786 if (PyErr_Occurred()) SWIG_fail;
46787 }
46788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46789 return resultobj;
46790 fail:
46791 return NULL;
46792 }
46793
46794
46795 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46796 PyObject *resultobj = 0;
46797 wxSizer *arg1 = (wxSizer *) 0 ;
46798 PyObject *arg2 = (PyObject *) 0 ;
46799 int arg3 = (int) 0 ;
46800 int arg4 = (int) 0 ;
46801 int arg5 = (int) 0 ;
46802 PyObject *arg6 = (PyObject *) NULL ;
46803 wxSizerItem *result = 0 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 int val3 ;
46807 int ecode3 = 0 ;
46808 int val4 ;
46809 int ecode4 = 0 ;
46810 int val5 ;
46811 int ecode5 = 0 ;
46812 PyObject * obj0 = 0 ;
46813 PyObject * obj1 = 0 ;
46814 PyObject * obj2 = 0 ;
46815 PyObject * obj3 = 0 ;
46816 PyObject * obj4 = 0 ;
46817 PyObject * obj5 = 0 ;
46818 char * kwnames[] = {
46819 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46820 };
46821
46822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46824 if (!SWIG_IsOK(res1)) {
46825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46826 }
46827 arg1 = reinterpret_cast< wxSizer * >(argp1);
46828 arg2 = obj1;
46829 if (obj2) {
46830 ecode3 = SWIG_AsVal_int(obj2, &val3);
46831 if (!SWIG_IsOK(ecode3)) {
46832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46833 }
46834 arg3 = static_cast< int >(val3);
46835 }
46836 if (obj3) {
46837 ecode4 = SWIG_AsVal_int(obj3, &val4);
46838 if (!SWIG_IsOK(ecode4)) {
46839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46840 }
46841 arg4 = static_cast< int >(val4);
46842 }
46843 if (obj4) {
46844 ecode5 = SWIG_AsVal_int(obj4, &val5);
46845 if (!SWIG_IsOK(ecode5)) {
46846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46847 }
46848 arg5 = static_cast< int >(val5);
46849 }
46850 if (obj5) {
46851 arg6 = obj5;
46852 }
46853 {
46854 PyThreadState* __tstate = wxPyBeginAllowThreads();
46855 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46856 wxPyEndAllowThreads(__tstate);
46857 if (PyErr_Occurred()) SWIG_fail;
46858 }
46859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46860 return resultobj;
46861 fail:
46862 return NULL;
46863 }
46864
46865
46866 SWIGINTERN PyObject *_wrap_Sizer_Remove(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_Remove",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_Remove" "', 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_Remove(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_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46902 PyObject *resultobj = 0;
46903 wxSizer *arg1 = (wxSizer *) 0 ;
46904 PyObject *arg2 = (PyObject *) 0 ;
46905 bool result;
46906 void *argp1 = 0 ;
46907 int res1 = 0 ;
46908 PyObject * obj0 = 0 ;
46909 PyObject * obj1 = 0 ;
46910 char * kwnames[] = {
46911 (char *) "self",(char *) "item", NULL
46912 };
46913
46914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46916 if (!SWIG_IsOK(res1)) {
46917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46918 }
46919 arg1 = reinterpret_cast< wxSizer * >(argp1);
46920 arg2 = obj1;
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 result = (bool)wxSizer_Detach(arg1,arg2);
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 {
46928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46929 }
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46937 PyObject *resultobj = 0;
46938 wxSizer *arg1 = (wxSizer *) 0 ;
46939 PyObject *arg2 = (PyObject *) 0 ;
46940 wxSizerItem *result = 0 ;
46941 void *argp1 = 0 ;
46942 int res1 = 0 ;
46943 PyObject * obj0 = 0 ;
46944 PyObject * obj1 = 0 ;
46945 char * kwnames[] = {
46946 (char *) "self",(char *) "item", NULL
46947 };
46948
46949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46951 if (!SWIG_IsOK(res1)) {
46952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46953 }
46954 arg1 = reinterpret_cast< wxSizer * >(argp1);
46955 arg2 = obj1;
46956 {
46957 PyThreadState* __tstate = wxPyBeginAllowThreads();
46958 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46959 wxPyEndAllowThreads(__tstate);
46960 if (PyErr_Occurred()) SWIG_fail;
46961 }
46962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46963 return resultobj;
46964 fail:
46965 return NULL;
46966 }
46967
46968
46969 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46970 PyObject *resultobj = 0;
46971 wxSizer *arg1 = (wxSizer *) 0 ;
46972 PyObject *arg2 = (PyObject *) 0 ;
46973 wxSize *arg3 = 0 ;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 wxSize temp3 ;
46977 PyObject * obj0 = 0 ;
46978 PyObject * obj1 = 0 ;
46979 PyObject * obj2 = 0 ;
46980 char * kwnames[] = {
46981 (char *) "self",(char *) "item",(char *) "size", NULL
46982 };
46983
46984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46988 }
46989 arg1 = reinterpret_cast< wxSizer * >(argp1);
46990 arg2 = obj1;
46991 {
46992 arg3 = &temp3;
46993 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46994 }
46995 {
46996 PyThreadState* __tstate = wxPyBeginAllowThreads();
46997 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46998 wxPyEndAllowThreads(__tstate);
46999 if (PyErr_Occurred()) SWIG_fail;
47000 }
47001 resultobj = SWIG_Py_Void();
47002 return resultobj;
47003 fail:
47004 return NULL;
47005 }
47006
47007
47008 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47009 PyObject *resultobj = 0;
47010 wxSizer *arg1 = (wxSizer *) 0 ;
47011 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47012 wxSizerItem *result = 0 ;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 int res2 = 0 ;
47016 PyObject * obj0 = 0 ;
47017 PyObject * obj1 = 0 ;
47018 char * kwnames[] = {
47019 (char *) "self",(char *) "item", NULL
47020 };
47021
47022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47024 if (!SWIG_IsOK(res1)) {
47025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47026 }
47027 arg1 = reinterpret_cast< wxSizer * >(argp1);
47028 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47029 if (!SWIG_IsOK(res2)) {
47030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47031 }
47032 {
47033 PyThreadState* __tstate = wxPyBeginAllowThreads();
47034 result = (wxSizerItem *)(arg1)->Add(arg2);
47035 wxPyEndAllowThreads(__tstate);
47036 if (PyErr_Occurred()) SWIG_fail;
47037 }
47038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47039 return resultobj;
47040 fail:
47041 return NULL;
47042 }
47043
47044
47045 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47046 PyObject *resultobj = 0;
47047 wxSizer *arg1 = (wxSizer *) 0 ;
47048 size_t arg2 ;
47049 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47050 wxSizerItem *result = 0 ;
47051 void *argp1 = 0 ;
47052 int res1 = 0 ;
47053 size_t val2 ;
47054 int ecode2 = 0 ;
47055 int res3 = 0 ;
47056 PyObject * obj0 = 0 ;
47057 PyObject * obj1 = 0 ;
47058 PyObject * obj2 = 0 ;
47059 char * kwnames[] = {
47060 (char *) "self",(char *) "index",(char *) "item", NULL
47061 };
47062
47063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47067 }
47068 arg1 = reinterpret_cast< wxSizer * >(argp1);
47069 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47070 if (!SWIG_IsOK(ecode2)) {
47071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47072 }
47073 arg2 = static_cast< size_t >(val2);
47074 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47075 if (!SWIG_IsOK(res3)) {
47076 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47077 }
47078 {
47079 PyThreadState* __tstate = wxPyBeginAllowThreads();
47080 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47081 wxPyEndAllowThreads(__tstate);
47082 if (PyErr_Occurred()) SWIG_fail;
47083 }
47084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47085 return resultobj;
47086 fail:
47087 return NULL;
47088 }
47089
47090
47091 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47092 PyObject *resultobj = 0;
47093 wxSizer *arg1 = (wxSizer *) 0 ;
47094 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47095 wxSizerItem *result = 0 ;
47096 void *argp1 = 0 ;
47097 int res1 = 0 ;
47098 int res2 = 0 ;
47099 PyObject * obj0 = 0 ;
47100 PyObject * obj1 = 0 ;
47101 char * kwnames[] = {
47102 (char *) "self",(char *) "item", NULL
47103 };
47104
47105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47107 if (!SWIG_IsOK(res1)) {
47108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47109 }
47110 arg1 = reinterpret_cast< wxSizer * >(argp1);
47111 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47112 if (!SWIG_IsOK(res2)) {
47113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47114 }
47115 {
47116 PyThreadState* __tstate = wxPyBeginAllowThreads();
47117 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47118 wxPyEndAllowThreads(__tstate);
47119 if (PyErr_Occurred()) SWIG_fail;
47120 }
47121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47122 return resultobj;
47123 fail:
47124 return NULL;
47125 }
47126
47127
47128 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47129 PyObject *resultobj = 0;
47130 wxSizer *arg1 = (wxSizer *) 0 ;
47131 int arg2 ;
47132 int arg3 ;
47133 int arg4 ;
47134 int arg5 ;
47135 void *argp1 = 0 ;
47136 int res1 = 0 ;
47137 int val2 ;
47138 int ecode2 = 0 ;
47139 int val3 ;
47140 int ecode3 = 0 ;
47141 int val4 ;
47142 int ecode4 = 0 ;
47143 int val5 ;
47144 int ecode5 = 0 ;
47145 PyObject * obj0 = 0 ;
47146 PyObject * obj1 = 0 ;
47147 PyObject * obj2 = 0 ;
47148 PyObject * obj3 = 0 ;
47149 PyObject * obj4 = 0 ;
47150 char * kwnames[] = {
47151 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47152 };
47153
47154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47156 if (!SWIG_IsOK(res1)) {
47157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47158 }
47159 arg1 = reinterpret_cast< wxSizer * >(argp1);
47160 ecode2 = SWIG_AsVal_int(obj1, &val2);
47161 if (!SWIG_IsOK(ecode2)) {
47162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47163 }
47164 arg2 = static_cast< int >(val2);
47165 ecode3 = SWIG_AsVal_int(obj2, &val3);
47166 if (!SWIG_IsOK(ecode3)) {
47167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47168 }
47169 arg3 = static_cast< int >(val3);
47170 ecode4 = SWIG_AsVal_int(obj3, &val4);
47171 if (!SWIG_IsOK(ecode4)) {
47172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47173 }
47174 arg4 = static_cast< int >(val4);
47175 ecode5 = SWIG_AsVal_int(obj4, &val5);
47176 if (!SWIG_IsOK(ecode5)) {
47177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47178 }
47179 arg5 = static_cast< int >(val5);
47180 {
47181 PyThreadState* __tstate = wxPyBeginAllowThreads();
47182 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47183 wxPyEndAllowThreads(__tstate);
47184 if (PyErr_Occurred()) SWIG_fail;
47185 }
47186 resultobj = SWIG_Py_Void();
47187 return resultobj;
47188 fail:
47189 return NULL;
47190 }
47191
47192
47193 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47194 PyObject *resultobj = 0;
47195 wxSizer *arg1 = (wxSizer *) 0 ;
47196 wxSize *arg2 = 0 ;
47197 void *argp1 = 0 ;
47198 int res1 = 0 ;
47199 wxSize temp2 ;
47200 PyObject * obj0 = 0 ;
47201 PyObject * obj1 = 0 ;
47202 char * kwnames[] = {
47203 (char *) "self",(char *) "size", NULL
47204 };
47205
47206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47210 }
47211 arg1 = reinterpret_cast< wxSizer * >(argp1);
47212 {
47213 arg2 = &temp2;
47214 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47215 }
47216 {
47217 PyThreadState* __tstate = wxPyBeginAllowThreads();
47218 (arg1)->SetMinSize((wxSize const &)*arg2);
47219 wxPyEndAllowThreads(__tstate);
47220 if (PyErr_Occurred()) SWIG_fail;
47221 }
47222 resultobj = SWIG_Py_Void();
47223 return resultobj;
47224 fail:
47225 return NULL;
47226 }
47227
47228
47229 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47230 PyObject *resultobj = 0;
47231 wxSizer *arg1 = (wxSizer *) 0 ;
47232 wxSize result;
47233 void *argp1 = 0 ;
47234 int res1 = 0 ;
47235 PyObject *swig_obj[1] ;
47236
47237 if (!args) SWIG_fail;
47238 swig_obj[0] = args;
47239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47240 if (!SWIG_IsOK(res1)) {
47241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47242 }
47243 arg1 = reinterpret_cast< wxSizer * >(argp1);
47244 {
47245 PyThreadState* __tstate = wxPyBeginAllowThreads();
47246 result = (arg1)->GetSize();
47247 wxPyEndAllowThreads(__tstate);
47248 if (PyErr_Occurred()) SWIG_fail;
47249 }
47250 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47251 return resultobj;
47252 fail:
47253 return NULL;
47254 }
47255
47256
47257 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47258 PyObject *resultobj = 0;
47259 wxSizer *arg1 = (wxSizer *) 0 ;
47260 wxPoint result;
47261 void *argp1 = 0 ;
47262 int res1 = 0 ;
47263 PyObject *swig_obj[1] ;
47264
47265 if (!args) SWIG_fail;
47266 swig_obj[0] = args;
47267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47268 if (!SWIG_IsOK(res1)) {
47269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47270 }
47271 arg1 = reinterpret_cast< wxSizer * >(argp1);
47272 {
47273 PyThreadState* __tstate = wxPyBeginAllowThreads();
47274 result = (arg1)->GetPosition();
47275 wxPyEndAllowThreads(__tstate);
47276 if (PyErr_Occurred()) SWIG_fail;
47277 }
47278 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47279 return resultobj;
47280 fail:
47281 return NULL;
47282 }
47283
47284
47285 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47286 PyObject *resultobj = 0;
47287 wxSizer *arg1 = (wxSizer *) 0 ;
47288 wxSize result;
47289 void *argp1 = 0 ;
47290 int res1 = 0 ;
47291 PyObject *swig_obj[1] ;
47292
47293 if (!args) SWIG_fail;
47294 swig_obj[0] = args;
47295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47298 }
47299 arg1 = reinterpret_cast< wxSizer * >(argp1);
47300 {
47301 PyThreadState* __tstate = wxPyBeginAllowThreads();
47302 result = (arg1)->GetMinSize();
47303 wxPyEndAllowThreads(__tstate);
47304 if (PyErr_Occurred()) SWIG_fail;
47305 }
47306 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47307 return resultobj;
47308 fail:
47309 return NULL;
47310 }
47311
47312
47313 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47314 PyObject *resultobj = 0;
47315 wxSizer *arg1 = (wxSizer *) 0 ;
47316 void *argp1 = 0 ;
47317 int res1 = 0 ;
47318 PyObject *swig_obj[1] ;
47319
47320 if (!args) SWIG_fail;
47321 swig_obj[0] = args;
47322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47323 if (!SWIG_IsOK(res1)) {
47324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47325 }
47326 arg1 = reinterpret_cast< wxSizer * >(argp1);
47327 {
47328 PyThreadState* __tstate = wxPyBeginAllowThreads();
47329 (arg1)->RecalcSizes();
47330 wxPyEndAllowThreads(__tstate);
47331 if (PyErr_Occurred()) SWIG_fail;
47332 }
47333 resultobj = SWIG_Py_Void();
47334 return resultobj;
47335 fail:
47336 return NULL;
47337 }
47338
47339
47340 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47341 PyObject *resultobj = 0;
47342 wxSizer *arg1 = (wxSizer *) 0 ;
47343 wxSize result;
47344 void *argp1 = 0 ;
47345 int res1 = 0 ;
47346 PyObject *swig_obj[1] ;
47347
47348 if (!args) SWIG_fail;
47349 swig_obj[0] = args;
47350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47351 if (!SWIG_IsOK(res1)) {
47352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47353 }
47354 arg1 = reinterpret_cast< wxSizer * >(argp1);
47355 {
47356 PyThreadState* __tstate = wxPyBeginAllowThreads();
47357 result = (arg1)->CalcMin();
47358 wxPyEndAllowThreads(__tstate);
47359 if (PyErr_Occurred()) SWIG_fail;
47360 }
47361 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47362 return resultobj;
47363 fail:
47364 return NULL;
47365 }
47366
47367
47368 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47369 PyObject *resultobj = 0;
47370 wxSizer *arg1 = (wxSizer *) 0 ;
47371 void *argp1 = 0 ;
47372 int res1 = 0 ;
47373 PyObject *swig_obj[1] ;
47374
47375 if (!args) SWIG_fail;
47376 swig_obj[0] = args;
47377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47378 if (!SWIG_IsOK(res1)) {
47379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47380 }
47381 arg1 = reinterpret_cast< wxSizer * >(argp1);
47382 {
47383 PyThreadState* __tstate = wxPyBeginAllowThreads();
47384 (arg1)->Layout();
47385 wxPyEndAllowThreads(__tstate);
47386 if (PyErr_Occurred()) SWIG_fail;
47387 }
47388 resultobj = SWIG_Py_Void();
47389 return resultobj;
47390 fail:
47391 return NULL;
47392 }
47393
47394
47395 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47396 PyObject *resultobj = 0;
47397 wxSizer *arg1 = (wxSizer *) 0 ;
47398 wxWindow *arg2 = (wxWindow *) 0 ;
47399 wxSize result;
47400 void *argp1 = 0 ;
47401 int res1 = 0 ;
47402 void *argp2 = 0 ;
47403 int res2 = 0 ;
47404 PyObject * obj0 = 0 ;
47405 PyObject * obj1 = 0 ;
47406 char * kwnames[] = {
47407 (char *) "self",(char *) "window", NULL
47408 };
47409
47410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47412 if (!SWIG_IsOK(res1)) {
47413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47414 }
47415 arg1 = reinterpret_cast< wxSizer * >(argp1);
47416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47417 if (!SWIG_IsOK(res2)) {
47418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47419 }
47420 arg2 = reinterpret_cast< wxWindow * >(argp2);
47421 {
47422 PyThreadState* __tstate = wxPyBeginAllowThreads();
47423 result = (arg1)->Fit(arg2);
47424 wxPyEndAllowThreads(__tstate);
47425 if (PyErr_Occurred()) SWIG_fail;
47426 }
47427 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47428 return resultobj;
47429 fail:
47430 return NULL;
47431 }
47432
47433
47434 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47435 PyObject *resultobj = 0;
47436 wxSizer *arg1 = (wxSizer *) 0 ;
47437 wxWindow *arg2 = (wxWindow *) 0 ;
47438 void *argp1 = 0 ;
47439 int res1 = 0 ;
47440 void *argp2 = 0 ;
47441 int res2 = 0 ;
47442 PyObject * obj0 = 0 ;
47443 PyObject * obj1 = 0 ;
47444 char * kwnames[] = {
47445 (char *) "self",(char *) "window", NULL
47446 };
47447
47448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47450 if (!SWIG_IsOK(res1)) {
47451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47452 }
47453 arg1 = reinterpret_cast< wxSizer * >(argp1);
47454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47455 if (!SWIG_IsOK(res2)) {
47456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47457 }
47458 arg2 = reinterpret_cast< wxWindow * >(argp2);
47459 {
47460 PyThreadState* __tstate = wxPyBeginAllowThreads();
47461 (arg1)->FitInside(arg2);
47462 wxPyEndAllowThreads(__tstate);
47463 if (PyErr_Occurred()) SWIG_fail;
47464 }
47465 resultobj = SWIG_Py_Void();
47466 return resultobj;
47467 fail:
47468 return NULL;
47469 }
47470
47471
47472 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47473 PyObject *resultobj = 0;
47474 wxSizer *arg1 = (wxSizer *) 0 ;
47475 wxWindow *arg2 = (wxWindow *) 0 ;
47476 void *argp1 = 0 ;
47477 int res1 = 0 ;
47478 void *argp2 = 0 ;
47479 int res2 = 0 ;
47480 PyObject * obj0 = 0 ;
47481 PyObject * obj1 = 0 ;
47482 char * kwnames[] = {
47483 (char *) "self",(char *) "window", NULL
47484 };
47485
47486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47488 if (!SWIG_IsOK(res1)) {
47489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47490 }
47491 arg1 = reinterpret_cast< wxSizer * >(argp1);
47492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47493 if (!SWIG_IsOK(res2)) {
47494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47495 }
47496 arg2 = reinterpret_cast< wxWindow * >(argp2);
47497 {
47498 PyThreadState* __tstate = wxPyBeginAllowThreads();
47499 (arg1)->SetSizeHints(arg2);
47500 wxPyEndAllowThreads(__tstate);
47501 if (PyErr_Occurred()) SWIG_fail;
47502 }
47503 resultobj = SWIG_Py_Void();
47504 return resultobj;
47505 fail:
47506 return NULL;
47507 }
47508
47509
47510 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47511 PyObject *resultobj = 0;
47512 wxSizer *arg1 = (wxSizer *) 0 ;
47513 wxWindow *arg2 = (wxWindow *) 0 ;
47514 void *argp1 = 0 ;
47515 int res1 = 0 ;
47516 void *argp2 = 0 ;
47517 int res2 = 0 ;
47518 PyObject * obj0 = 0 ;
47519 PyObject * obj1 = 0 ;
47520 char * kwnames[] = {
47521 (char *) "self",(char *) "window", NULL
47522 };
47523
47524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47526 if (!SWIG_IsOK(res1)) {
47527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47528 }
47529 arg1 = reinterpret_cast< wxSizer * >(argp1);
47530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47531 if (!SWIG_IsOK(res2)) {
47532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47533 }
47534 arg2 = reinterpret_cast< wxWindow * >(argp2);
47535 {
47536 PyThreadState* __tstate = wxPyBeginAllowThreads();
47537 (arg1)->SetVirtualSizeHints(arg2);
47538 wxPyEndAllowThreads(__tstate);
47539 if (PyErr_Occurred()) SWIG_fail;
47540 }
47541 resultobj = SWIG_Py_Void();
47542 return resultobj;
47543 fail:
47544 return NULL;
47545 }
47546
47547
47548 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47549 PyObject *resultobj = 0;
47550 wxSizer *arg1 = (wxSizer *) 0 ;
47551 bool arg2 = (bool) false ;
47552 void *argp1 = 0 ;
47553 int res1 = 0 ;
47554 bool val2 ;
47555 int ecode2 = 0 ;
47556 PyObject * obj0 = 0 ;
47557 PyObject * obj1 = 0 ;
47558 char * kwnames[] = {
47559 (char *) "self",(char *) "deleteWindows", NULL
47560 };
47561
47562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47564 if (!SWIG_IsOK(res1)) {
47565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47566 }
47567 arg1 = reinterpret_cast< wxSizer * >(argp1);
47568 if (obj1) {
47569 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47570 if (!SWIG_IsOK(ecode2)) {
47571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47572 }
47573 arg2 = static_cast< bool >(val2);
47574 }
47575 {
47576 PyThreadState* __tstate = wxPyBeginAllowThreads();
47577 (arg1)->Clear(arg2);
47578 wxPyEndAllowThreads(__tstate);
47579 if (PyErr_Occurred()) SWIG_fail;
47580 }
47581 resultobj = SWIG_Py_Void();
47582 return resultobj;
47583 fail:
47584 return NULL;
47585 }
47586
47587
47588 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47589 PyObject *resultobj = 0;
47590 wxSizer *arg1 = (wxSizer *) 0 ;
47591 void *argp1 = 0 ;
47592 int res1 = 0 ;
47593 PyObject *swig_obj[1] ;
47594
47595 if (!args) SWIG_fail;
47596 swig_obj[0] = args;
47597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47598 if (!SWIG_IsOK(res1)) {
47599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47600 }
47601 arg1 = reinterpret_cast< wxSizer * >(argp1);
47602 {
47603 PyThreadState* __tstate = wxPyBeginAllowThreads();
47604 (arg1)->DeleteWindows();
47605 wxPyEndAllowThreads(__tstate);
47606 if (PyErr_Occurred()) SWIG_fail;
47607 }
47608 resultobj = SWIG_Py_Void();
47609 return resultobj;
47610 fail:
47611 return NULL;
47612 }
47613
47614
47615 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47616 PyObject *resultobj = 0;
47617 wxSizer *arg1 = (wxSizer *) 0 ;
47618 PyObject *result = 0 ;
47619 void *argp1 = 0 ;
47620 int res1 = 0 ;
47621 PyObject *swig_obj[1] ;
47622
47623 if (!args) SWIG_fail;
47624 swig_obj[0] = args;
47625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47626 if (!SWIG_IsOK(res1)) {
47627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47628 }
47629 arg1 = reinterpret_cast< wxSizer * >(argp1);
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 result = (PyObject *)wxSizer_GetChildren(arg1);
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = result;
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxSizer *arg1 = (wxSizer *) 0 ;
47646 PyObject *arg2 = (PyObject *) 0 ;
47647 bool arg3 = (bool) true ;
47648 bool arg4 = (bool) false ;
47649 bool result;
47650 void *argp1 = 0 ;
47651 int res1 = 0 ;
47652 bool val3 ;
47653 int ecode3 = 0 ;
47654 bool val4 ;
47655 int ecode4 = 0 ;
47656 PyObject * obj0 = 0 ;
47657 PyObject * obj1 = 0 ;
47658 PyObject * obj2 = 0 ;
47659 PyObject * obj3 = 0 ;
47660 char * kwnames[] = {
47661 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47662 };
47663
47664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47666 if (!SWIG_IsOK(res1)) {
47667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47668 }
47669 arg1 = reinterpret_cast< wxSizer * >(argp1);
47670 arg2 = obj1;
47671 if (obj2) {
47672 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47673 if (!SWIG_IsOK(ecode3)) {
47674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47675 }
47676 arg3 = static_cast< bool >(val3);
47677 }
47678 if (obj3) {
47679 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47680 if (!SWIG_IsOK(ecode4)) {
47681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47682 }
47683 arg4 = static_cast< bool >(val4);
47684 }
47685 {
47686 PyThreadState* __tstate = wxPyBeginAllowThreads();
47687 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47688 wxPyEndAllowThreads(__tstate);
47689 if (PyErr_Occurred()) SWIG_fail;
47690 }
47691 {
47692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47693 }
47694 return resultobj;
47695 fail:
47696 return NULL;
47697 }
47698
47699
47700 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47701 PyObject *resultobj = 0;
47702 wxSizer *arg1 = (wxSizer *) 0 ;
47703 PyObject *arg2 = (PyObject *) 0 ;
47704 bool result;
47705 void *argp1 = 0 ;
47706 int res1 = 0 ;
47707 PyObject * obj0 = 0 ;
47708 PyObject * obj1 = 0 ;
47709 char * kwnames[] = {
47710 (char *) "self",(char *) "item", NULL
47711 };
47712
47713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47715 if (!SWIG_IsOK(res1)) {
47716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47717 }
47718 arg1 = reinterpret_cast< wxSizer * >(argp1);
47719 arg2 = obj1;
47720 {
47721 PyThreadState* __tstate = wxPyBeginAllowThreads();
47722 result = (bool)wxSizer_IsShown(arg1,arg2);
47723 wxPyEndAllowThreads(__tstate);
47724 if (PyErr_Occurred()) SWIG_fail;
47725 }
47726 {
47727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47728 }
47729 return resultobj;
47730 fail:
47731 return NULL;
47732 }
47733
47734
47735 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47736 PyObject *resultobj = 0;
47737 wxSizer *arg1 = (wxSizer *) 0 ;
47738 bool arg2 ;
47739 void *argp1 = 0 ;
47740 int res1 = 0 ;
47741 bool val2 ;
47742 int ecode2 = 0 ;
47743 PyObject * obj0 = 0 ;
47744 PyObject * obj1 = 0 ;
47745 char * kwnames[] = {
47746 (char *) "self",(char *) "show", NULL
47747 };
47748
47749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47751 if (!SWIG_IsOK(res1)) {
47752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47753 }
47754 arg1 = reinterpret_cast< wxSizer * >(argp1);
47755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47756 if (!SWIG_IsOK(ecode2)) {
47757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47758 }
47759 arg2 = static_cast< bool >(val2);
47760 {
47761 PyThreadState* __tstate = wxPyBeginAllowThreads();
47762 (arg1)->ShowItems(arg2);
47763 wxPyEndAllowThreads(__tstate);
47764 if (PyErr_Occurred()) SWIG_fail;
47765 }
47766 resultobj = SWIG_Py_Void();
47767 return resultobj;
47768 fail:
47769 return NULL;
47770 }
47771
47772
47773 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47774 PyObject *obj;
47775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47776 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47777 return SWIG_Py_Void();
47778 }
47779
47780 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47781 PyObject *resultobj = 0;
47782 wxPySizer *result = 0 ;
47783
47784 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47785 {
47786 PyThreadState* __tstate = wxPyBeginAllowThreads();
47787 result = (wxPySizer *)new wxPySizer();
47788 wxPyEndAllowThreads(__tstate);
47789 if (PyErr_Occurred()) SWIG_fail;
47790 }
47791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47792 return resultobj;
47793 fail:
47794 return NULL;
47795 }
47796
47797
47798 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47799 PyObject *resultobj = 0;
47800 wxPySizer *arg1 = (wxPySizer *) 0 ;
47801 PyObject *arg2 = (PyObject *) 0 ;
47802 PyObject *arg3 = (PyObject *) 0 ;
47803 void *argp1 = 0 ;
47804 int res1 = 0 ;
47805 PyObject * obj0 = 0 ;
47806 PyObject * obj1 = 0 ;
47807 PyObject * obj2 = 0 ;
47808 char * kwnames[] = {
47809 (char *) "self",(char *) "self",(char *) "_class", NULL
47810 };
47811
47812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47814 if (!SWIG_IsOK(res1)) {
47815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47816 }
47817 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47818 arg2 = obj1;
47819 arg3 = obj2;
47820 {
47821 PyThreadState* __tstate = wxPyBeginAllowThreads();
47822 (arg1)->_setCallbackInfo(arg2,arg3);
47823 wxPyEndAllowThreads(__tstate);
47824 if (PyErr_Occurred()) SWIG_fail;
47825 }
47826 resultobj = SWIG_Py_Void();
47827 return resultobj;
47828 fail:
47829 return NULL;
47830 }
47831
47832
47833 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47834 PyObject *obj;
47835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47836 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47837 return SWIG_Py_Void();
47838 }
47839
47840 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47841 return SWIG_Python_InitShadowInstance(args);
47842 }
47843
47844 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47845 PyObject *resultobj = 0;
47846 int arg1 = (int) wxHORIZONTAL ;
47847 wxBoxSizer *result = 0 ;
47848 int val1 ;
47849 int ecode1 = 0 ;
47850 PyObject * obj0 = 0 ;
47851 char * kwnames[] = {
47852 (char *) "orient", NULL
47853 };
47854
47855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47856 if (obj0) {
47857 ecode1 = SWIG_AsVal_int(obj0, &val1);
47858 if (!SWIG_IsOK(ecode1)) {
47859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47860 }
47861 arg1 = static_cast< int >(val1);
47862 }
47863 {
47864 PyThreadState* __tstate = wxPyBeginAllowThreads();
47865 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47866 wxPyEndAllowThreads(__tstate);
47867 if (PyErr_Occurred()) SWIG_fail;
47868 }
47869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47870 return resultobj;
47871 fail:
47872 return NULL;
47873 }
47874
47875
47876 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47877 PyObject *resultobj = 0;
47878 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47879 int result;
47880 void *argp1 = 0 ;
47881 int res1 = 0 ;
47882 PyObject *swig_obj[1] ;
47883
47884 if (!args) SWIG_fail;
47885 swig_obj[0] = args;
47886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47889 }
47890 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 result = (int)(arg1)->GetOrientation();
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 resultobj = SWIG_From_int(static_cast< int >(result));
47898 return resultobj;
47899 fail:
47900 return NULL;
47901 }
47902
47903
47904 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47905 PyObject *resultobj = 0;
47906 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47907 int arg2 ;
47908 void *argp1 = 0 ;
47909 int res1 = 0 ;
47910 int val2 ;
47911 int ecode2 = 0 ;
47912 PyObject * obj0 = 0 ;
47913 PyObject * obj1 = 0 ;
47914 char * kwnames[] = {
47915 (char *) "self",(char *) "orient", NULL
47916 };
47917
47918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47920 if (!SWIG_IsOK(res1)) {
47921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47922 }
47923 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47924 ecode2 = SWIG_AsVal_int(obj1, &val2);
47925 if (!SWIG_IsOK(ecode2)) {
47926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47927 }
47928 arg2 = static_cast< int >(val2);
47929 {
47930 PyThreadState* __tstate = wxPyBeginAllowThreads();
47931 (arg1)->SetOrientation(arg2);
47932 wxPyEndAllowThreads(__tstate);
47933 if (PyErr_Occurred()) SWIG_fail;
47934 }
47935 resultobj = SWIG_Py_Void();
47936 return resultobj;
47937 fail:
47938 return NULL;
47939 }
47940
47941
47942 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47943 PyObject *obj;
47944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47945 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47946 return SWIG_Py_Void();
47947 }
47948
47949 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47950 return SWIG_Python_InitShadowInstance(args);
47951 }
47952
47953 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47954 PyObject *resultobj = 0;
47955 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47956 int arg2 = (int) wxHORIZONTAL ;
47957 wxStaticBoxSizer *result = 0 ;
47958 void *argp1 = 0 ;
47959 int res1 = 0 ;
47960 int val2 ;
47961 int ecode2 = 0 ;
47962 PyObject * obj0 = 0 ;
47963 PyObject * obj1 = 0 ;
47964 char * kwnames[] = {
47965 (char *) "box",(char *) "orient", NULL
47966 };
47967
47968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47970 if (!SWIG_IsOK(res1)) {
47971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47972 }
47973 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47974 if (obj1) {
47975 ecode2 = SWIG_AsVal_int(obj1, &val2);
47976 if (!SWIG_IsOK(ecode2)) {
47977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47978 }
47979 arg2 = static_cast< int >(val2);
47980 }
47981 {
47982 PyThreadState* __tstate = wxPyBeginAllowThreads();
47983 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47984 wxPyEndAllowThreads(__tstate);
47985 if (PyErr_Occurred()) SWIG_fail;
47986 }
47987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47988 return resultobj;
47989 fail:
47990 return NULL;
47991 }
47992
47993
47994 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47995 PyObject *resultobj = 0;
47996 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47997 wxStaticBox *result = 0 ;
47998 void *argp1 = 0 ;
47999 int res1 = 0 ;
48000 PyObject *swig_obj[1] ;
48001
48002 if (!args) SWIG_fail;
48003 swig_obj[0] = args;
48004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48005 if (!SWIG_IsOK(res1)) {
48006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48007 }
48008 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48009 {
48010 PyThreadState* __tstate = wxPyBeginAllowThreads();
48011 result = (wxStaticBox *)(arg1)->GetStaticBox();
48012 wxPyEndAllowThreads(__tstate);
48013 if (PyErr_Occurred()) SWIG_fail;
48014 }
48015 {
48016 resultobj = wxPyMake_wxObject(result, (bool)0);
48017 }
48018 return resultobj;
48019 fail:
48020 return NULL;
48021 }
48022
48023
48024 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48025 PyObject *obj;
48026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48027 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48028 return SWIG_Py_Void();
48029 }
48030
48031 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48032 return SWIG_Python_InitShadowInstance(args);
48033 }
48034
48035 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48036 PyObject *resultobj = 0;
48037 int arg1 = (int) 1 ;
48038 int arg2 = (int) 0 ;
48039 int arg3 = (int) 0 ;
48040 int arg4 = (int) 0 ;
48041 wxGridSizer *result = 0 ;
48042 int val1 ;
48043 int ecode1 = 0 ;
48044 int val2 ;
48045 int ecode2 = 0 ;
48046 int val3 ;
48047 int ecode3 = 0 ;
48048 int val4 ;
48049 int ecode4 = 0 ;
48050 PyObject * obj0 = 0 ;
48051 PyObject * obj1 = 0 ;
48052 PyObject * obj2 = 0 ;
48053 PyObject * obj3 = 0 ;
48054 char * kwnames[] = {
48055 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48056 };
48057
48058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48059 if (obj0) {
48060 ecode1 = SWIG_AsVal_int(obj0, &val1);
48061 if (!SWIG_IsOK(ecode1)) {
48062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48063 }
48064 arg1 = static_cast< int >(val1);
48065 }
48066 if (obj1) {
48067 ecode2 = SWIG_AsVal_int(obj1, &val2);
48068 if (!SWIG_IsOK(ecode2)) {
48069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48070 }
48071 arg2 = static_cast< int >(val2);
48072 }
48073 if (obj2) {
48074 ecode3 = SWIG_AsVal_int(obj2, &val3);
48075 if (!SWIG_IsOK(ecode3)) {
48076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48077 }
48078 arg3 = static_cast< int >(val3);
48079 }
48080 if (obj3) {
48081 ecode4 = SWIG_AsVal_int(obj3, &val4);
48082 if (!SWIG_IsOK(ecode4)) {
48083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48084 }
48085 arg4 = static_cast< int >(val4);
48086 }
48087 {
48088 PyThreadState* __tstate = wxPyBeginAllowThreads();
48089 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48090 wxPyEndAllowThreads(__tstate);
48091 if (PyErr_Occurred()) SWIG_fail;
48092 }
48093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48094 return resultobj;
48095 fail:
48096 return NULL;
48097 }
48098
48099
48100 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48101 PyObject *resultobj = 0;
48102 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48103 int arg2 ;
48104 void *argp1 = 0 ;
48105 int res1 = 0 ;
48106 int val2 ;
48107 int ecode2 = 0 ;
48108 PyObject * obj0 = 0 ;
48109 PyObject * obj1 = 0 ;
48110 char * kwnames[] = {
48111 (char *) "self",(char *) "cols", NULL
48112 };
48113
48114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48116 if (!SWIG_IsOK(res1)) {
48117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48118 }
48119 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48120 ecode2 = SWIG_AsVal_int(obj1, &val2);
48121 if (!SWIG_IsOK(ecode2)) {
48122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48123 }
48124 arg2 = static_cast< int >(val2);
48125 {
48126 PyThreadState* __tstate = wxPyBeginAllowThreads();
48127 (arg1)->SetCols(arg2);
48128 wxPyEndAllowThreads(__tstate);
48129 if (PyErr_Occurred()) SWIG_fail;
48130 }
48131 resultobj = SWIG_Py_Void();
48132 return resultobj;
48133 fail:
48134 return NULL;
48135 }
48136
48137
48138 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48139 PyObject *resultobj = 0;
48140 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48141 int arg2 ;
48142 void *argp1 = 0 ;
48143 int res1 = 0 ;
48144 int val2 ;
48145 int ecode2 = 0 ;
48146 PyObject * obj0 = 0 ;
48147 PyObject * obj1 = 0 ;
48148 char * kwnames[] = {
48149 (char *) "self",(char *) "rows", NULL
48150 };
48151
48152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48154 if (!SWIG_IsOK(res1)) {
48155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48156 }
48157 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48158 ecode2 = SWIG_AsVal_int(obj1, &val2);
48159 if (!SWIG_IsOK(ecode2)) {
48160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48161 }
48162 arg2 = static_cast< int >(val2);
48163 {
48164 PyThreadState* __tstate = wxPyBeginAllowThreads();
48165 (arg1)->SetRows(arg2);
48166 wxPyEndAllowThreads(__tstate);
48167 if (PyErr_Occurred()) SWIG_fail;
48168 }
48169 resultobj = SWIG_Py_Void();
48170 return resultobj;
48171 fail:
48172 return NULL;
48173 }
48174
48175
48176 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48177 PyObject *resultobj = 0;
48178 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48179 int arg2 ;
48180 void *argp1 = 0 ;
48181 int res1 = 0 ;
48182 int val2 ;
48183 int ecode2 = 0 ;
48184 PyObject * obj0 = 0 ;
48185 PyObject * obj1 = 0 ;
48186 char * kwnames[] = {
48187 (char *) "self",(char *) "gap", NULL
48188 };
48189
48190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48192 if (!SWIG_IsOK(res1)) {
48193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48194 }
48195 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48196 ecode2 = SWIG_AsVal_int(obj1, &val2);
48197 if (!SWIG_IsOK(ecode2)) {
48198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48199 }
48200 arg2 = static_cast< int >(val2);
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 (arg1)->SetVGap(arg2);
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_Py_Void();
48208 return resultobj;
48209 fail:
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48217 int arg2 ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 int val2 ;
48221 int ecode2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "gap", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48234 ecode2 = SWIG_AsVal_int(obj1, &val2);
48235 if (!SWIG_IsOK(ecode2)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48237 }
48238 arg2 = static_cast< int >(val2);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->SetHGap(arg2);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48253 PyObject *resultobj = 0;
48254 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48255 int result;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 PyObject *swig_obj[1] ;
48259
48260 if (!args) SWIG_fail;
48261 swig_obj[0] = args;
48262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48265 }
48266 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48267 {
48268 PyThreadState* __tstate = wxPyBeginAllowThreads();
48269 result = (int)(arg1)->GetCols();
48270 wxPyEndAllowThreads(__tstate);
48271 if (PyErr_Occurred()) SWIG_fail;
48272 }
48273 resultobj = SWIG_From_int(static_cast< int >(result));
48274 return resultobj;
48275 fail:
48276 return NULL;
48277 }
48278
48279
48280 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48281 PyObject *resultobj = 0;
48282 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48283 int result;
48284 void *argp1 = 0 ;
48285 int res1 = 0 ;
48286 PyObject *swig_obj[1] ;
48287
48288 if (!args) SWIG_fail;
48289 swig_obj[0] = args;
48290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48291 if (!SWIG_IsOK(res1)) {
48292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48293 }
48294 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48295 {
48296 PyThreadState* __tstate = wxPyBeginAllowThreads();
48297 result = (int)(arg1)->GetRows();
48298 wxPyEndAllowThreads(__tstate);
48299 if (PyErr_Occurred()) SWIG_fail;
48300 }
48301 resultobj = SWIG_From_int(static_cast< int >(result));
48302 return resultobj;
48303 fail:
48304 return NULL;
48305 }
48306
48307
48308 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48309 PyObject *resultobj = 0;
48310 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48311 int result;
48312 void *argp1 = 0 ;
48313 int res1 = 0 ;
48314 PyObject *swig_obj[1] ;
48315
48316 if (!args) SWIG_fail;
48317 swig_obj[0] = args;
48318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48319 if (!SWIG_IsOK(res1)) {
48320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48321 }
48322 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48323 {
48324 PyThreadState* __tstate = wxPyBeginAllowThreads();
48325 result = (int)(arg1)->GetVGap();
48326 wxPyEndAllowThreads(__tstate);
48327 if (PyErr_Occurred()) SWIG_fail;
48328 }
48329 resultobj = SWIG_From_int(static_cast< int >(result));
48330 return resultobj;
48331 fail:
48332 return NULL;
48333 }
48334
48335
48336 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48337 PyObject *resultobj = 0;
48338 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48339 int result;
48340 void *argp1 = 0 ;
48341 int res1 = 0 ;
48342 PyObject *swig_obj[1] ;
48343
48344 if (!args) SWIG_fail;
48345 swig_obj[0] = args;
48346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48347 if (!SWIG_IsOK(res1)) {
48348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48349 }
48350 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48351 {
48352 PyThreadState* __tstate = wxPyBeginAllowThreads();
48353 result = (int)(arg1)->GetHGap();
48354 wxPyEndAllowThreads(__tstate);
48355 if (PyErr_Occurred()) SWIG_fail;
48356 }
48357 resultobj = SWIG_From_int(static_cast< int >(result));
48358 return resultobj;
48359 fail:
48360 return NULL;
48361 }
48362
48363
48364 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48365 PyObject *obj;
48366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48367 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48368 return SWIG_Py_Void();
48369 }
48370
48371 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48372 return SWIG_Python_InitShadowInstance(args);
48373 }
48374
48375 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48376 PyObject *resultobj = 0;
48377 int arg1 = (int) 1 ;
48378 int arg2 = (int) 0 ;
48379 int arg3 = (int) 0 ;
48380 int arg4 = (int) 0 ;
48381 wxFlexGridSizer *result = 0 ;
48382 int val1 ;
48383 int ecode1 = 0 ;
48384 int val2 ;
48385 int ecode2 = 0 ;
48386 int val3 ;
48387 int ecode3 = 0 ;
48388 int val4 ;
48389 int ecode4 = 0 ;
48390 PyObject * obj0 = 0 ;
48391 PyObject * obj1 = 0 ;
48392 PyObject * obj2 = 0 ;
48393 PyObject * obj3 = 0 ;
48394 char * kwnames[] = {
48395 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48396 };
48397
48398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48399 if (obj0) {
48400 ecode1 = SWIG_AsVal_int(obj0, &val1);
48401 if (!SWIG_IsOK(ecode1)) {
48402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48403 }
48404 arg1 = static_cast< int >(val1);
48405 }
48406 if (obj1) {
48407 ecode2 = SWIG_AsVal_int(obj1, &val2);
48408 if (!SWIG_IsOK(ecode2)) {
48409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48410 }
48411 arg2 = static_cast< int >(val2);
48412 }
48413 if (obj2) {
48414 ecode3 = SWIG_AsVal_int(obj2, &val3);
48415 if (!SWIG_IsOK(ecode3)) {
48416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48417 }
48418 arg3 = static_cast< int >(val3);
48419 }
48420 if (obj3) {
48421 ecode4 = SWIG_AsVal_int(obj3, &val4);
48422 if (!SWIG_IsOK(ecode4)) {
48423 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48424 }
48425 arg4 = static_cast< int >(val4);
48426 }
48427 {
48428 PyThreadState* __tstate = wxPyBeginAllowThreads();
48429 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48430 wxPyEndAllowThreads(__tstate);
48431 if (PyErr_Occurred()) SWIG_fail;
48432 }
48433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48434 return resultobj;
48435 fail:
48436 return NULL;
48437 }
48438
48439
48440 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48441 PyObject *resultobj = 0;
48442 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48443 size_t arg2 ;
48444 int arg3 = (int) 0 ;
48445 void *argp1 = 0 ;
48446 int res1 = 0 ;
48447 size_t val2 ;
48448 int ecode2 = 0 ;
48449 int val3 ;
48450 int ecode3 = 0 ;
48451 PyObject * obj0 = 0 ;
48452 PyObject * obj1 = 0 ;
48453 PyObject * obj2 = 0 ;
48454 char * kwnames[] = {
48455 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48456 };
48457
48458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48460 if (!SWIG_IsOK(res1)) {
48461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48462 }
48463 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48464 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48465 if (!SWIG_IsOK(ecode2)) {
48466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48467 }
48468 arg2 = static_cast< size_t >(val2);
48469 if (obj2) {
48470 ecode3 = SWIG_AsVal_int(obj2, &val3);
48471 if (!SWIG_IsOK(ecode3)) {
48472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48473 }
48474 arg3 = static_cast< int >(val3);
48475 }
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 (arg1)->AddGrowableRow(arg2,arg3);
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_Py_Void();
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48490 PyObject *resultobj = 0;
48491 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48492 size_t arg2 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 size_t val2 ;
48496 int ecode2 = 0 ;
48497 PyObject * obj0 = 0 ;
48498 PyObject * obj1 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "self",(char *) "idx", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48505 if (!SWIG_IsOK(res1)) {
48506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48507 }
48508 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48509 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48510 if (!SWIG_IsOK(ecode2)) {
48511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48512 }
48513 arg2 = static_cast< size_t >(val2);
48514 {
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 (arg1)->RemoveGrowableRow(arg2);
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 resultobj = SWIG_Py_Void();
48521 return resultobj;
48522 fail:
48523 return NULL;
48524 }
48525
48526
48527 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48528 PyObject *resultobj = 0;
48529 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48530 size_t arg2 ;
48531 int arg3 = (int) 0 ;
48532 void *argp1 = 0 ;
48533 int res1 = 0 ;
48534 size_t val2 ;
48535 int ecode2 = 0 ;
48536 int val3 ;
48537 int ecode3 = 0 ;
48538 PyObject * obj0 = 0 ;
48539 PyObject * obj1 = 0 ;
48540 PyObject * obj2 = 0 ;
48541 char * kwnames[] = {
48542 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48543 };
48544
48545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48547 if (!SWIG_IsOK(res1)) {
48548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48549 }
48550 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48551 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48552 if (!SWIG_IsOK(ecode2)) {
48553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48554 }
48555 arg2 = static_cast< size_t >(val2);
48556 if (obj2) {
48557 ecode3 = SWIG_AsVal_int(obj2, &val3);
48558 if (!SWIG_IsOK(ecode3)) {
48559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48560 }
48561 arg3 = static_cast< int >(val3);
48562 }
48563 {
48564 PyThreadState* __tstate = wxPyBeginAllowThreads();
48565 (arg1)->AddGrowableCol(arg2,arg3);
48566 wxPyEndAllowThreads(__tstate);
48567 if (PyErr_Occurred()) SWIG_fail;
48568 }
48569 resultobj = SWIG_Py_Void();
48570 return resultobj;
48571 fail:
48572 return NULL;
48573 }
48574
48575
48576 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48577 PyObject *resultobj = 0;
48578 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48579 size_t arg2 ;
48580 void *argp1 = 0 ;
48581 int res1 = 0 ;
48582 size_t val2 ;
48583 int ecode2 = 0 ;
48584 PyObject * obj0 = 0 ;
48585 PyObject * obj1 = 0 ;
48586 char * kwnames[] = {
48587 (char *) "self",(char *) "idx", NULL
48588 };
48589
48590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48592 if (!SWIG_IsOK(res1)) {
48593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48594 }
48595 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48596 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48597 if (!SWIG_IsOK(ecode2)) {
48598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48599 }
48600 arg2 = static_cast< size_t >(val2);
48601 {
48602 PyThreadState* __tstate = wxPyBeginAllowThreads();
48603 (arg1)->RemoveGrowableCol(arg2);
48604 wxPyEndAllowThreads(__tstate);
48605 if (PyErr_Occurred()) SWIG_fail;
48606 }
48607 resultobj = SWIG_Py_Void();
48608 return resultobj;
48609 fail:
48610 return NULL;
48611 }
48612
48613
48614 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48615 PyObject *resultobj = 0;
48616 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48617 int arg2 ;
48618 void *argp1 = 0 ;
48619 int res1 = 0 ;
48620 int val2 ;
48621 int ecode2 = 0 ;
48622 PyObject * obj0 = 0 ;
48623 PyObject * obj1 = 0 ;
48624 char * kwnames[] = {
48625 (char *) "self",(char *) "direction", NULL
48626 };
48627
48628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48630 if (!SWIG_IsOK(res1)) {
48631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48632 }
48633 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48634 ecode2 = SWIG_AsVal_int(obj1, &val2);
48635 if (!SWIG_IsOK(ecode2)) {
48636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48637 }
48638 arg2 = static_cast< int >(val2);
48639 {
48640 PyThreadState* __tstate = wxPyBeginAllowThreads();
48641 (arg1)->SetFlexibleDirection(arg2);
48642 wxPyEndAllowThreads(__tstate);
48643 if (PyErr_Occurred()) SWIG_fail;
48644 }
48645 resultobj = SWIG_Py_Void();
48646 return resultobj;
48647 fail:
48648 return NULL;
48649 }
48650
48651
48652 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48653 PyObject *resultobj = 0;
48654 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48655 int result;
48656 void *argp1 = 0 ;
48657 int res1 = 0 ;
48658 PyObject *swig_obj[1] ;
48659
48660 if (!args) SWIG_fail;
48661 swig_obj[0] = args;
48662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48663 if (!SWIG_IsOK(res1)) {
48664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48665 }
48666 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 result = (int)(arg1)->GetFlexibleDirection();
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_From_int(static_cast< int >(result));
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48681 PyObject *resultobj = 0;
48682 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48683 wxFlexSizerGrowMode arg2 ;
48684 void *argp1 = 0 ;
48685 int res1 = 0 ;
48686 int val2 ;
48687 int ecode2 = 0 ;
48688 PyObject * obj0 = 0 ;
48689 PyObject * obj1 = 0 ;
48690 char * kwnames[] = {
48691 (char *) "self",(char *) "mode", NULL
48692 };
48693
48694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48698 }
48699 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48700 ecode2 = SWIG_AsVal_int(obj1, &val2);
48701 if (!SWIG_IsOK(ecode2)) {
48702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48703 }
48704 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48705 {
48706 PyThreadState* __tstate = wxPyBeginAllowThreads();
48707 (arg1)->SetNonFlexibleGrowMode(arg2);
48708 wxPyEndAllowThreads(__tstate);
48709 if (PyErr_Occurred()) SWIG_fail;
48710 }
48711 resultobj = SWIG_Py_Void();
48712 return resultobj;
48713 fail:
48714 return NULL;
48715 }
48716
48717
48718 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48719 PyObject *resultobj = 0;
48720 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48721 wxFlexSizerGrowMode result;
48722 void *argp1 = 0 ;
48723 int res1 = 0 ;
48724 PyObject *swig_obj[1] ;
48725
48726 if (!args) SWIG_fail;
48727 swig_obj[0] = args;
48728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48729 if (!SWIG_IsOK(res1)) {
48730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48731 }
48732 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48733 {
48734 PyThreadState* __tstate = wxPyBeginAllowThreads();
48735 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48736 wxPyEndAllowThreads(__tstate);
48737 if (PyErr_Occurred()) SWIG_fail;
48738 }
48739 resultobj = SWIG_From_int(static_cast< int >(result));
48740 return resultobj;
48741 fail:
48742 return NULL;
48743 }
48744
48745
48746 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48747 PyObject *resultobj = 0;
48748 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48749 wxArrayInt *result = 0 ;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 PyObject *swig_obj[1] ;
48753
48754 if (!args) SWIG_fail;
48755 swig_obj[0] = args;
48756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48757 if (!SWIG_IsOK(res1)) {
48758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48759 }
48760 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48761 {
48762 PyThreadState* __tstate = wxPyBeginAllowThreads();
48763 {
48764 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48765 result = (wxArrayInt *) &_result_ref;
48766 }
48767 wxPyEndAllowThreads(__tstate);
48768 if (PyErr_Occurred()) SWIG_fail;
48769 }
48770 {
48771 resultobj = PyList_New(0);
48772 size_t idx;
48773 for (idx = 0; idx < result->GetCount(); idx += 1) {
48774 PyObject* val = PyInt_FromLong( result->Item(idx) );
48775 PyList_Append(resultobj, val);
48776 Py_DECREF(val);
48777 }
48778 }
48779 return resultobj;
48780 fail:
48781 return NULL;
48782 }
48783
48784
48785 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48786 PyObject *resultobj = 0;
48787 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48788 wxArrayInt *result = 0 ;
48789 void *argp1 = 0 ;
48790 int res1 = 0 ;
48791 PyObject *swig_obj[1] ;
48792
48793 if (!args) SWIG_fail;
48794 swig_obj[0] = args;
48795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48796 if (!SWIG_IsOK(res1)) {
48797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48798 }
48799 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 {
48803 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48804 result = (wxArrayInt *) &_result_ref;
48805 }
48806 wxPyEndAllowThreads(__tstate);
48807 if (PyErr_Occurred()) SWIG_fail;
48808 }
48809 {
48810 resultobj = PyList_New(0);
48811 size_t idx;
48812 for (idx = 0; idx < result->GetCount(); idx += 1) {
48813 PyObject* val = PyInt_FromLong( result->Item(idx) );
48814 PyList_Append(resultobj, val);
48815 Py_DECREF(val);
48816 }
48817 }
48818 return resultobj;
48819 fail:
48820 return NULL;
48821 }
48822
48823
48824 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48825 PyObject *obj;
48826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48827 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48828 return SWIG_Py_Void();
48829 }
48830
48831 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48832 return SWIG_Python_InitShadowInstance(args);
48833 }
48834
48835 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48836 PyObject *resultobj = 0;
48837 wxStdDialogButtonSizer *result = 0 ;
48838
48839 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48840 {
48841 PyThreadState* __tstate = wxPyBeginAllowThreads();
48842 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48843 wxPyEndAllowThreads(__tstate);
48844 if (PyErr_Occurred()) SWIG_fail;
48845 }
48846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48847 return resultobj;
48848 fail:
48849 return NULL;
48850 }
48851
48852
48853 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48854 PyObject *resultobj = 0;
48855 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48856 wxButton *arg2 = (wxButton *) 0 ;
48857 void *argp1 = 0 ;
48858 int res1 = 0 ;
48859 void *argp2 = 0 ;
48860 int res2 = 0 ;
48861 PyObject * obj0 = 0 ;
48862 PyObject * obj1 = 0 ;
48863 char * kwnames[] = {
48864 (char *) "self",(char *) "button", NULL
48865 };
48866
48867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48869 if (!SWIG_IsOK(res1)) {
48870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48871 }
48872 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48874 if (!SWIG_IsOK(res2)) {
48875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48876 }
48877 arg2 = reinterpret_cast< wxButton * >(argp2);
48878 {
48879 PyThreadState* __tstate = wxPyBeginAllowThreads();
48880 (arg1)->AddButton(arg2);
48881 wxPyEndAllowThreads(__tstate);
48882 if (PyErr_Occurred()) SWIG_fail;
48883 }
48884 resultobj = SWIG_Py_Void();
48885 return resultobj;
48886 fail:
48887 return NULL;
48888 }
48889
48890
48891 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48892 PyObject *resultobj = 0;
48893 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 PyObject *swig_obj[1] ;
48897
48898 if (!args) SWIG_fail;
48899 swig_obj[0] = args;
48900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48901 if (!SWIG_IsOK(res1)) {
48902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48903 }
48904 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48905 {
48906 PyThreadState* __tstate = wxPyBeginAllowThreads();
48907 (arg1)->Realize();
48908 wxPyEndAllowThreads(__tstate);
48909 if (PyErr_Occurred()) SWIG_fail;
48910 }
48911 resultobj = SWIG_Py_Void();
48912 return resultobj;
48913 fail:
48914 return NULL;
48915 }
48916
48917
48918 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48919 PyObject *resultobj = 0;
48920 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48921 wxButton *arg2 = (wxButton *) 0 ;
48922 void *argp1 = 0 ;
48923 int res1 = 0 ;
48924 void *argp2 = 0 ;
48925 int res2 = 0 ;
48926 PyObject * obj0 = 0 ;
48927 PyObject * obj1 = 0 ;
48928 char * kwnames[] = {
48929 (char *) "self",(char *) "button", NULL
48930 };
48931
48932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48934 if (!SWIG_IsOK(res1)) {
48935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48936 }
48937 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48939 if (!SWIG_IsOK(res2)) {
48940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48941 }
48942 arg2 = reinterpret_cast< wxButton * >(argp2);
48943 {
48944 PyThreadState* __tstate = wxPyBeginAllowThreads();
48945 (arg1)->SetAffirmativeButton(arg2);
48946 wxPyEndAllowThreads(__tstate);
48947 if (PyErr_Occurred()) SWIG_fail;
48948 }
48949 resultobj = SWIG_Py_Void();
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48957 PyObject *resultobj = 0;
48958 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48959 wxButton *arg2 = (wxButton *) 0 ;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 void *argp2 = 0 ;
48963 int res2 = 0 ;
48964 PyObject * obj0 = 0 ;
48965 PyObject * obj1 = 0 ;
48966 char * kwnames[] = {
48967 (char *) "self",(char *) "button", NULL
48968 };
48969
48970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48972 if (!SWIG_IsOK(res1)) {
48973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48974 }
48975 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48977 if (!SWIG_IsOK(res2)) {
48978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48979 }
48980 arg2 = reinterpret_cast< wxButton * >(argp2);
48981 {
48982 PyThreadState* __tstate = wxPyBeginAllowThreads();
48983 (arg1)->SetNegativeButton(arg2);
48984 wxPyEndAllowThreads(__tstate);
48985 if (PyErr_Occurred()) SWIG_fail;
48986 }
48987 resultobj = SWIG_Py_Void();
48988 return resultobj;
48989 fail:
48990 return NULL;
48991 }
48992
48993
48994 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48995 PyObject *resultobj = 0;
48996 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48997 wxButton *arg2 = (wxButton *) 0 ;
48998 void *argp1 = 0 ;
48999 int res1 = 0 ;
49000 void *argp2 = 0 ;
49001 int res2 = 0 ;
49002 PyObject * obj0 = 0 ;
49003 PyObject * obj1 = 0 ;
49004 char * kwnames[] = {
49005 (char *) "self",(char *) "button", NULL
49006 };
49007
49008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49010 if (!SWIG_IsOK(res1)) {
49011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49012 }
49013 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49014 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49015 if (!SWIG_IsOK(res2)) {
49016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49017 }
49018 arg2 = reinterpret_cast< wxButton * >(argp2);
49019 {
49020 PyThreadState* __tstate = wxPyBeginAllowThreads();
49021 (arg1)->SetCancelButton(arg2);
49022 wxPyEndAllowThreads(__tstate);
49023 if (PyErr_Occurred()) SWIG_fail;
49024 }
49025 resultobj = SWIG_Py_Void();
49026 return resultobj;
49027 fail:
49028 return NULL;
49029 }
49030
49031
49032 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49033 PyObject *resultobj = 0;
49034 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49035 wxButton *result = 0 ;
49036 void *argp1 = 0 ;
49037 int res1 = 0 ;
49038 PyObject *swig_obj[1] ;
49039
49040 if (!args) SWIG_fail;
49041 swig_obj[0] = args;
49042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49043 if (!SWIG_IsOK(res1)) {
49044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49045 }
49046 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49047 {
49048 PyThreadState* __tstate = wxPyBeginAllowThreads();
49049 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49050 wxPyEndAllowThreads(__tstate);
49051 if (PyErr_Occurred()) SWIG_fail;
49052 }
49053 {
49054 resultobj = wxPyMake_wxObject(result, (bool)0);
49055 }
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49065 wxButton *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_wxStdDialogButtonSizer, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49075 }
49076 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 {
49084 resultobj = wxPyMake_wxObject(result, (bool)0);
49085 }
49086 return resultobj;
49087 fail:
49088 return NULL;
49089 }
49090
49091
49092 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49093 PyObject *resultobj = 0;
49094 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49095 wxButton *result = 0 ;
49096 void *argp1 = 0 ;
49097 int res1 = 0 ;
49098 PyObject *swig_obj[1] ;
49099
49100 if (!args) SWIG_fail;
49101 swig_obj[0] = args;
49102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49103 if (!SWIG_IsOK(res1)) {
49104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49105 }
49106 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49107 {
49108 PyThreadState* __tstate = wxPyBeginAllowThreads();
49109 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49110 wxPyEndAllowThreads(__tstate);
49111 if (PyErr_Occurred()) SWIG_fail;
49112 }
49113 {
49114 resultobj = wxPyMake_wxObject(result, (bool)0);
49115 }
49116 return resultobj;
49117 fail:
49118 return NULL;
49119 }
49120
49121
49122 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49123 PyObject *resultobj = 0;
49124 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49125 wxButton *result = 0 ;
49126 void *argp1 = 0 ;
49127 int res1 = 0 ;
49128 PyObject *swig_obj[1] ;
49129
49130 if (!args) SWIG_fail;
49131 swig_obj[0] = args;
49132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49133 if (!SWIG_IsOK(res1)) {
49134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49135 }
49136 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49137 {
49138 PyThreadState* __tstate = wxPyBeginAllowThreads();
49139 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49140 wxPyEndAllowThreads(__tstate);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 {
49144 resultobj = wxPyMake_wxObject(result, (bool)0);
49145 }
49146 return resultobj;
49147 fail:
49148 return NULL;
49149 }
49150
49151
49152 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49153 PyObject *resultobj = 0;
49154 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49155 wxButton *result = 0 ;
49156 void *argp1 = 0 ;
49157 int res1 = 0 ;
49158 PyObject *swig_obj[1] ;
49159
49160 if (!args) SWIG_fail;
49161 swig_obj[0] = args;
49162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49163 if (!SWIG_IsOK(res1)) {
49164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49165 }
49166 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49167 {
49168 PyThreadState* __tstate = wxPyBeginAllowThreads();
49169 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49170 wxPyEndAllowThreads(__tstate);
49171 if (PyErr_Occurred()) SWIG_fail;
49172 }
49173 {
49174 resultobj = wxPyMake_wxObject(result, (bool)0);
49175 }
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49183 PyObject *obj;
49184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49185 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49186 return SWIG_Py_Void();
49187 }
49188
49189 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49190 return SWIG_Python_InitShadowInstance(args);
49191 }
49192
49193 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 int arg1 = (int) 0 ;
49196 int arg2 = (int) 0 ;
49197 wxGBPosition *result = 0 ;
49198 int val1 ;
49199 int ecode1 = 0 ;
49200 int val2 ;
49201 int ecode2 = 0 ;
49202 PyObject * obj0 = 0 ;
49203 PyObject * obj1 = 0 ;
49204 char * kwnames[] = {
49205 (char *) "row",(char *) "col", NULL
49206 };
49207
49208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49209 if (obj0) {
49210 ecode1 = SWIG_AsVal_int(obj0, &val1);
49211 if (!SWIG_IsOK(ecode1)) {
49212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49213 }
49214 arg1 = static_cast< int >(val1);
49215 }
49216 if (obj1) {
49217 ecode2 = SWIG_AsVal_int(obj1, &val2);
49218 if (!SWIG_IsOK(ecode2)) {
49219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49220 }
49221 arg2 = static_cast< int >(val2);
49222 }
49223 {
49224 PyThreadState* __tstate = wxPyBeginAllowThreads();
49225 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49226 wxPyEndAllowThreads(__tstate);
49227 if (PyErr_Occurred()) SWIG_fail;
49228 }
49229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49230 return resultobj;
49231 fail:
49232 return NULL;
49233 }
49234
49235
49236 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49237 PyObject *resultobj = 0;
49238 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 PyObject *swig_obj[1] ;
49242
49243 if (!args) SWIG_fail;
49244 swig_obj[0] = args;
49245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49246 if (!SWIG_IsOK(res1)) {
49247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49248 }
49249 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49250 {
49251 PyThreadState* __tstate = wxPyBeginAllowThreads();
49252 delete arg1;
49253
49254 wxPyEndAllowThreads(__tstate);
49255 if (PyErr_Occurred()) SWIG_fail;
49256 }
49257 resultobj = SWIG_Py_Void();
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49265 PyObject *resultobj = 0;
49266 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49267 int result;
49268 void *argp1 = 0 ;
49269 int res1 = 0 ;
49270 PyObject *swig_obj[1] ;
49271
49272 if (!args) SWIG_fail;
49273 swig_obj[0] = args;
49274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49275 if (!SWIG_IsOK(res1)) {
49276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49277 }
49278 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49279 {
49280 PyThreadState* __tstate = wxPyBeginAllowThreads();
49281 result = (int)((wxGBPosition const *)arg1)->GetRow();
49282 wxPyEndAllowThreads(__tstate);
49283 if (PyErr_Occurred()) SWIG_fail;
49284 }
49285 resultobj = SWIG_From_int(static_cast< int >(result));
49286 return resultobj;
49287 fail:
49288 return NULL;
49289 }
49290
49291
49292 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49293 PyObject *resultobj = 0;
49294 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49295 int result;
49296 void *argp1 = 0 ;
49297 int res1 = 0 ;
49298 PyObject *swig_obj[1] ;
49299
49300 if (!args) SWIG_fail;
49301 swig_obj[0] = args;
49302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49303 if (!SWIG_IsOK(res1)) {
49304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49305 }
49306 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49307 {
49308 PyThreadState* __tstate = wxPyBeginAllowThreads();
49309 result = (int)((wxGBPosition const *)arg1)->GetCol();
49310 wxPyEndAllowThreads(__tstate);
49311 if (PyErr_Occurred()) SWIG_fail;
49312 }
49313 resultobj = SWIG_From_int(static_cast< int >(result));
49314 return resultobj;
49315 fail:
49316 return NULL;
49317 }
49318
49319
49320 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49321 PyObject *resultobj = 0;
49322 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49323 int arg2 ;
49324 void *argp1 = 0 ;
49325 int res1 = 0 ;
49326 int val2 ;
49327 int ecode2 = 0 ;
49328 PyObject * obj0 = 0 ;
49329 PyObject * obj1 = 0 ;
49330 char * kwnames[] = {
49331 (char *) "self",(char *) "row", NULL
49332 };
49333
49334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49336 if (!SWIG_IsOK(res1)) {
49337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49338 }
49339 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49340 ecode2 = SWIG_AsVal_int(obj1, &val2);
49341 if (!SWIG_IsOK(ecode2)) {
49342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49343 }
49344 arg2 = static_cast< int >(val2);
49345 {
49346 PyThreadState* __tstate = wxPyBeginAllowThreads();
49347 (arg1)->SetRow(arg2);
49348 wxPyEndAllowThreads(__tstate);
49349 if (PyErr_Occurred()) SWIG_fail;
49350 }
49351 resultobj = SWIG_Py_Void();
49352 return resultobj;
49353 fail:
49354 return NULL;
49355 }
49356
49357
49358 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49359 PyObject *resultobj = 0;
49360 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49361 int arg2 ;
49362 void *argp1 = 0 ;
49363 int res1 = 0 ;
49364 int val2 ;
49365 int ecode2 = 0 ;
49366 PyObject * obj0 = 0 ;
49367 PyObject * obj1 = 0 ;
49368 char * kwnames[] = {
49369 (char *) "self",(char *) "col", NULL
49370 };
49371
49372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49374 if (!SWIG_IsOK(res1)) {
49375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49376 }
49377 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49378 ecode2 = SWIG_AsVal_int(obj1, &val2);
49379 if (!SWIG_IsOK(ecode2)) {
49380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49381 }
49382 arg2 = static_cast< int >(val2);
49383 {
49384 PyThreadState* __tstate = wxPyBeginAllowThreads();
49385 (arg1)->SetCol(arg2);
49386 wxPyEndAllowThreads(__tstate);
49387 if (PyErr_Occurred()) SWIG_fail;
49388 }
49389 resultobj = SWIG_Py_Void();
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49397 PyObject *resultobj = 0;
49398 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49399 PyObject *arg2 = (PyObject *) 0 ;
49400 bool result;
49401 void *argp1 = 0 ;
49402 int res1 = 0 ;
49403 PyObject * obj0 = 0 ;
49404 PyObject * obj1 = 0 ;
49405 char * kwnames[] = {
49406 (char *) "self",(char *) "other", NULL
49407 };
49408
49409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49411 if (!SWIG_IsOK(res1)) {
49412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49413 }
49414 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49415 arg2 = obj1;
49416 {
49417 result = (bool)wxGBPosition___eq__(arg1,arg2);
49418 if (PyErr_Occurred()) SWIG_fail;
49419 }
49420 {
49421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49422 }
49423 return resultobj;
49424 fail:
49425 return NULL;
49426 }
49427
49428
49429 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49430 PyObject *resultobj = 0;
49431 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49432 PyObject *arg2 = (PyObject *) 0 ;
49433 bool result;
49434 void *argp1 = 0 ;
49435 int res1 = 0 ;
49436 PyObject * obj0 = 0 ;
49437 PyObject * obj1 = 0 ;
49438 char * kwnames[] = {
49439 (char *) "self",(char *) "other", NULL
49440 };
49441
49442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49444 if (!SWIG_IsOK(res1)) {
49445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49446 }
49447 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49448 arg2 = obj1;
49449 {
49450 result = (bool)wxGBPosition___ne__(arg1,arg2);
49451 if (PyErr_Occurred()) SWIG_fail;
49452 }
49453 {
49454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49455 }
49456 return resultobj;
49457 fail:
49458 return NULL;
49459 }
49460
49461
49462 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49463 PyObject *resultobj = 0;
49464 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49465 int arg2 = (int) 0 ;
49466 int arg3 = (int) 0 ;
49467 void *argp1 = 0 ;
49468 int res1 = 0 ;
49469 int val2 ;
49470 int ecode2 = 0 ;
49471 int val3 ;
49472 int ecode3 = 0 ;
49473 PyObject * obj0 = 0 ;
49474 PyObject * obj1 = 0 ;
49475 PyObject * obj2 = 0 ;
49476 char * kwnames[] = {
49477 (char *) "self",(char *) "row",(char *) "col", NULL
49478 };
49479
49480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49482 if (!SWIG_IsOK(res1)) {
49483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49484 }
49485 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49486 if (obj1) {
49487 ecode2 = SWIG_AsVal_int(obj1, &val2);
49488 if (!SWIG_IsOK(ecode2)) {
49489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49490 }
49491 arg2 = static_cast< int >(val2);
49492 }
49493 if (obj2) {
49494 ecode3 = SWIG_AsVal_int(obj2, &val3);
49495 if (!SWIG_IsOK(ecode3)) {
49496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49497 }
49498 arg3 = static_cast< int >(val3);
49499 }
49500 {
49501 PyThreadState* __tstate = wxPyBeginAllowThreads();
49502 wxGBPosition_Set(arg1,arg2,arg3);
49503 wxPyEndAllowThreads(__tstate);
49504 if (PyErr_Occurred()) SWIG_fail;
49505 }
49506 resultobj = SWIG_Py_Void();
49507 return resultobj;
49508 fail:
49509 return NULL;
49510 }
49511
49512
49513 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49514 PyObject *resultobj = 0;
49515 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49516 PyObject *result = 0 ;
49517 void *argp1 = 0 ;
49518 int res1 = 0 ;
49519 PyObject *swig_obj[1] ;
49520
49521 if (!args) SWIG_fail;
49522 swig_obj[0] = args;
49523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49524 if (!SWIG_IsOK(res1)) {
49525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49526 }
49527 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49528 {
49529 PyThreadState* __tstate = wxPyBeginAllowThreads();
49530 result = (PyObject *)wxGBPosition_Get(arg1);
49531 wxPyEndAllowThreads(__tstate);
49532 if (PyErr_Occurred()) SWIG_fail;
49533 }
49534 resultobj = result;
49535 return resultobj;
49536 fail:
49537 return NULL;
49538 }
49539
49540
49541 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49542 PyObject *obj;
49543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49544 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49545 return SWIG_Py_Void();
49546 }
49547
49548 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49549 return SWIG_Python_InitShadowInstance(args);
49550 }
49551
49552 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49553 PyObject *resultobj = 0;
49554 int arg1 = (int) 1 ;
49555 int arg2 = (int) 1 ;
49556 wxGBSpan *result = 0 ;
49557 int val1 ;
49558 int ecode1 = 0 ;
49559 int val2 ;
49560 int ecode2 = 0 ;
49561 PyObject * obj0 = 0 ;
49562 PyObject * obj1 = 0 ;
49563 char * kwnames[] = {
49564 (char *) "rowspan",(char *) "colspan", NULL
49565 };
49566
49567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49568 if (obj0) {
49569 ecode1 = SWIG_AsVal_int(obj0, &val1);
49570 if (!SWIG_IsOK(ecode1)) {
49571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49572 }
49573 arg1 = static_cast< int >(val1);
49574 }
49575 if (obj1) {
49576 ecode2 = SWIG_AsVal_int(obj1, &val2);
49577 if (!SWIG_IsOK(ecode2)) {
49578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49579 }
49580 arg2 = static_cast< int >(val2);
49581 }
49582 {
49583 PyThreadState* __tstate = wxPyBeginAllowThreads();
49584 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49585 wxPyEndAllowThreads(__tstate);
49586 if (PyErr_Occurred()) SWIG_fail;
49587 }
49588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49589 return resultobj;
49590 fail:
49591 return NULL;
49592 }
49593
49594
49595 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49596 PyObject *resultobj = 0;
49597 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49598 void *argp1 = 0 ;
49599 int res1 = 0 ;
49600 PyObject *swig_obj[1] ;
49601
49602 if (!args) SWIG_fail;
49603 swig_obj[0] = args;
49604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49605 if (!SWIG_IsOK(res1)) {
49606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49607 }
49608 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49609 {
49610 PyThreadState* __tstate = wxPyBeginAllowThreads();
49611 delete arg1;
49612
49613 wxPyEndAllowThreads(__tstate);
49614 if (PyErr_Occurred()) SWIG_fail;
49615 }
49616 resultobj = SWIG_Py_Void();
49617 return resultobj;
49618 fail:
49619 return NULL;
49620 }
49621
49622
49623 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49624 PyObject *resultobj = 0;
49625 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49626 int result;
49627 void *argp1 = 0 ;
49628 int res1 = 0 ;
49629 PyObject *swig_obj[1] ;
49630
49631 if (!args) SWIG_fail;
49632 swig_obj[0] = args;
49633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49634 if (!SWIG_IsOK(res1)) {
49635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49636 }
49637 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49638 {
49639 PyThreadState* __tstate = wxPyBeginAllowThreads();
49640 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49641 wxPyEndAllowThreads(__tstate);
49642 if (PyErr_Occurred()) SWIG_fail;
49643 }
49644 resultobj = SWIG_From_int(static_cast< int >(result));
49645 return resultobj;
49646 fail:
49647 return NULL;
49648 }
49649
49650
49651 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49652 PyObject *resultobj = 0;
49653 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49654 int result;
49655 void *argp1 = 0 ;
49656 int res1 = 0 ;
49657 PyObject *swig_obj[1] ;
49658
49659 if (!args) SWIG_fail;
49660 swig_obj[0] = args;
49661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49662 if (!SWIG_IsOK(res1)) {
49663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49664 }
49665 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49666 {
49667 PyThreadState* __tstate = wxPyBeginAllowThreads();
49668 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49669 wxPyEndAllowThreads(__tstate);
49670 if (PyErr_Occurred()) SWIG_fail;
49671 }
49672 resultobj = SWIG_From_int(static_cast< int >(result));
49673 return resultobj;
49674 fail:
49675 return NULL;
49676 }
49677
49678
49679 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49680 PyObject *resultobj = 0;
49681 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49682 int arg2 ;
49683 void *argp1 = 0 ;
49684 int res1 = 0 ;
49685 int val2 ;
49686 int ecode2 = 0 ;
49687 PyObject * obj0 = 0 ;
49688 PyObject * obj1 = 0 ;
49689 char * kwnames[] = {
49690 (char *) "self",(char *) "rowspan", NULL
49691 };
49692
49693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49695 if (!SWIG_IsOK(res1)) {
49696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49697 }
49698 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49699 ecode2 = SWIG_AsVal_int(obj1, &val2);
49700 if (!SWIG_IsOK(ecode2)) {
49701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49702 }
49703 arg2 = static_cast< int >(val2);
49704 {
49705 PyThreadState* __tstate = wxPyBeginAllowThreads();
49706 (arg1)->SetRowspan(arg2);
49707 wxPyEndAllowThreads(__tstate);
49708 if (PyErr_Occurred()) SWIG_fail;
49709 }
49710 resultobj = SWIG_Py_Void();
49711 return resultobj;
49712 fail:
49713 return NULL;
49714 }
49715
49716
49717 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49718 PyObject *resultobj = 0;
49719 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49720 int arg2 ;
49721 void *argp1 = 0 ;
49722 int res1 = 0 ;
49723 int val2 ;
49724 int ecode2 = 0 ;
49725 PyObject * obj0 = 0 ;
49726 PyObject * obj1 = 0 ;
49727 char * kwnames[] = {
49728 (char *) "self",(char *) "colspan", NULL
49729 };
49730
49731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49733 if (!SWIG_IsOK(res1)) {
49734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49735 }
49736 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49737 ecode2 = SWIG_AsVal_int(obj1, &val2);
49738 if (!SWIG_IsOK(ecode2)) {
49739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49740 }
49741 arg2 = static_cast< int >(val2);
49742 {
49743 PyThreadState* __tstate = wxPyBeginAllowThreads();
49744 (arg1)->SetColspan(arg2);
49745 wxPyEndAllowThreads(__tstate);
49746 if (PyErr_Occurred()) SWIG_fail;
49747 }
49748 resultobj = SWIG_Py_Void();
49749 return resultobj;
49750 fail:
49751 return NULL;
49752 }
49753
49754
49755 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49756 PyObject *resultobj = 0;
49757 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49758 PyObject *arg2 = (PyObject *) 0 ;
49759 bool result;
49760 void *argp1 = 0 ;
49761 int res1 = 0 ;
49762 PyObject * obj0 = 0 ;
49763 PyObject * obj1 = 0 ;
49764 char * kwnames[] = {
49765 (char *) "self",(char *) "other", NULL
49766 };
49767
49768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49770 if (!SWIG_IsOK(res1)) {
49771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49772 }
49773 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49774 arg2 = obj1;
49775 {
49776 result = (bool)wxGBSpan___eq__(arg1,arg2);
49777 if (PyErr_Occurred()) SWIG_fail;
49778 }
49779 {
49780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49781 }
49782 return resultobj;
49783 fail:
49784 return NULL;
49785 }
49786
49787
49788 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49789 PyObject *resultobj = 0;
49790 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49791 PyObject *arg2 = (PyObject *) 0 ;
49792 bool result;
49793 void *argp1 = 0 ;
49794 int res1 = 0 ;
49795 PyObject * obj0 = 0 ;
49796 PyObject * obj1 = 0 ;
49797 char * kwnames[] = {
49798 (char *) "self",(char *) "other", NULL
49799 };
49800
49801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49805 }
49806 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49807 arg2 = obj1;
49808 {
49809 result = (bool)wxGBSpan___ne__(arg1,arg2);
49810 if (PyErr_Occurred()) SWIG_fail;
49811 }
49812 {
49813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49814 }
49815 return resultobj;
49816 fail:
49817 return NULL;
49818 }
49819
49820
49821 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49822 PyObject *resultobj = 0;
49823 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49824 int arg2 = (int) 1 ;
49825 int arg3 = (int) 1 ;
49826 void *argp1 = 0 ;
49827 int res1 = 0 ;
49828 int val2 ;
49829 int ecode2 = 0 ;
49830 int val3 ;
49831 int ecode3 = 0 ;
49832 PyObject * obj0 = 0 ;
49833 PyObject * obj1 = 0 ;
49834 PyObject * obj2 = 0 ;
49835 char * kwnames[] = {
49836 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49837 };
49838
49839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49841 if (!SWIG_IsOK(res1)) {
49842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49843 }
49844 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49845 if (obj1) {
49846 ecode2 = SWIG_AsVal_int(obj1, &val2);
49847 if (!SWIG_IsOK(ecode2)) {
49848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49849 }
49850 arg2 = static_cast< int >(val2);
49851 }
49852 if (obj2) {
49853 ecode3 = SWIG_AsVal_int(obj2, &val3);
49854 if (!SWIG_IsOK(ecode3)) {
49855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49856 }
49857 arg3 = static_cast< int >(val3);
49858 }
49859 {
49860 PyThreadState* __tstate = wxPyBeginAllowThreads();
49861 wxGBSpan_Set(arg1,arg2,arg3);
49862 wxPyEndAllowThreads(__tstate);
49863 if (PyErr_Occurred()) SWIG_fail;
49864 }
49865 resultobj = SWIG_Py_Void();
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49873 PyObject *resultobj = 0;
49874 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49875 PyObject *result = 0 ;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 PyObject *swig_obj[1] ;
49879
49880 if (!args) SWIG_fail;
49881 swig_obj[0] = args;
49882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49883 if (!SWIG_IsOK(res1)) {
49884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49885 }
49886 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49887 {
49888 PyThreadState* __tstate = wxPyBeginAllowThreads();
49889 result = (PyObject *)wxGBSpan_Get(arg1);
49890 wxPyEndAllowThreads(__tstate);
49891 if (PyErr_Occurred()) SWIG_fail;
49892 }
49893 resultobj = result;
49894 return resultobj;
49895 fail:
49896 return NULL;
49897 }
49898
49899
49900 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49901 PyObject *obj;
49902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49904 return SWIG_Py_Void();
49905 }
49906
49907 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49908 return SWIG_Python_InitShadowInstance(args);
49909 }
49910
49911 SWIGINTERN int DefaultSpan_set(PyObject *) {
49912 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49913 return 1;
49914 }
49915
49916
49917 SWIGINTERN PyObject *DefaultSpan_get(void) {
49918 PyObject *pyobj = 0;
49919
49920 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49921 return pyobj;
49922 }
49923
49924
49925 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49926 PyObject *resultobj = 0;
49927 wxGBSizerItem *result = 0 ;
49928
49929 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49930 {
49931 PyThreadState* __tstate = wxPyBeginAllowThreads();
49932 result = (wxGBSizerItem *)new wxGBSizerItem();
49933 wxPyEndAllowThreads(__tstate);
49934 if (PyErr_Occurred()) SWIG_fail;
49935 }
49936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49944 PyObject *resultobj = 0;
49945 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49946 void *argp1 = 0 ;
49947 int res1 = 0 ;
49948 PyObject *swig_obj[1] ;
49949
49950 if (!args) SWIG_fail;
49951 swig_obj[0] = args;
49952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49953 if (!SWIG_IsOK(res1)) {
49954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49955 }
49956 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49957 {
49958 PyThreadState* __tstate = wxPyBeginAllowThreads();
49959 delete arg1;
49960
49961 wxPyEndAllowThreads(__tstate);
49962 if (PyErr_Occurred()) SWIG_fail;
49963 }
49964 resultobj = SWIG_Py_Void();
49965 return resultobj;
49966 fail:
49967 return NULL;
49968 }
49969
49970
49971 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49972 PyObject *resultobj = 0;
49973 wxWindow *arg1 = (wxWindow *) 0 ;
49974 wxGBPosition *arg2 = 0 ;
49975 wxGBSpan *arg3 = 0 ;
49976 int arg4 ;
49977 int arg5 ;
49978 PyObject *arg6 = (PyObject *) NULL ;
49979 wxGBSizerItem *result = 0 ;
49980 void *argp1 = 0 ;
49981 int res1 = 0 ;
49982 wxGBPosition temp2 ;
49983 wxGBSpan temp3 ;
49984 int val4 ;
49985 int ecode4 = 0 ;
49986 int val5 ;
49987 int ecode5 = 0 ;
49988 PyObject * obj0 = 0 ;
49989 PyObject * obj1 = 0 ;
49990 PyObject * obj2 = 0 ;
49991 PyObject * obj3 = 0 ;
49992 PyObject * obj4 = 0 ;
49993 PyObject * obj5 = 0 ;
49994 char * kwnames[] = {
49995 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49996 };
49997
49998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50000 if (!SWIG_IsOK(res1)) {
50001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50002 }
50003 arg1 = reinterpret_cast< wxWindow * >(argp1);
50004 {
50005 arg2 = &temp2;
50006 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50007 }
50008 {
50009 arg3 = &temp3;
50010 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50011 }
50012 ecode4 = SWIG_AsVal_int(obj3, &val4);
50013 if (!SWIG_IsOK(ecode4)) {
50014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50015 }
50016 arg4 = static_cast< int >(val4);
50017 ecode5 = SWIG_AsVal_int(obj4, &val5);
50018 if (!SWIG_IsOK(ecode5)) {
50019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50020 }
50021 arg5 = static_cast< int >(val5);
50022 if (obj5) {
50023 arg6 = obj5;
50024 }
50025 {
50026 PyThreadState* __tstate = wxPyBeginAllowThreads();
50027 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50028 wxPyEndAllowThreads(__tstate);
50029 if (PyErr_Occurred()) SWIG_fail;
50030 }
50031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50032 return resultobj;
50033 fail:
50034 return NULL;
50035 }
50036
50037
50038 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50039 PyObject *resultobj = 0;
50040 wxSizer *arg1 = (wxSizer *) 0 ;
50041 wxGBPosition *arg2 = 0 ;
50042 wxGBSpan *arg3 = 0 ;
50043 int arg4 ;
50044 int arg5 ;
50045 PyObject *arg6 = (PyObject *) NULL ;
50046 wxGBSizerItem *result = 0 ;
50047 int res1 = 0 ;
50048 wxGBPosition temp2 ;
50049 wxGBSpan temp3 ;
50050 int val4 ;
50051 int ecode4 = 0 ;
50052 int val5 ;
50053 int ecode5 = 0 ;
50054 PyObject * obj0 = 0 ;
50055 PyObject * obj1 = 0 ;
50056 PyObject * obj2 = 0 ;
50057 PyObject * obj3 = 0 ;
50058 PyObject * obj4 = 0 ;
50059 PyObject * obj5 = 0 ;
50060 char * kwnames[] = {
50061 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50062 };
50063
50064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50065 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50066 if (!SWIG_IsOK(res1)) {
50067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50068 }
50069 {
50070 arg2 = &temp2;
50071 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50072 }
50073 {
50074 arg3 = &temp3;
50075 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50076 }
50077 ecode4 = SWIG_AsVal_int(obj3, &val4);
50078 if (!SWIG_IsOK(ecode4)) {
50079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50080 }
50081 arg4 = static_cast< int >(val4);
50082 ecode5 = SWIG_AsVal_int(obj4, &val5);
50083 if (!SWIG_IsOK(ecode5)) {
50084 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50085 }
50086 arg5 = static_cast< int >(val5);
50087 if (obj5) {
50088 arg6 = obj5;
50089 }
50090 {
50091 PyThreadState* __tstate = wxPyBeginAllowThreads();
50092 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50093 wxPyEndAllowThreads(__tstate);
50094 if (PyErr_Occurred()) SWIG_fail;
50095 }
50096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50097 return resultobj;
50098 fail:
50099 return NULL;
50100 }
50101
50102
50103 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50104 PyObject *resultobj = 0;
50105 int arg1 ;
50106 int arg2 ;
50107 wxGBPosition *arg3 = 0 ;
50108 wxGBSpan *arg4 = 0 ;
50109 int arg5 ;
50110 int arg6 ;
50111 PyObject *arg7 = (PyObject *) NULL ;
50112 wxGBSizerItem *result = 0 ;
50113 int val1 ;
50114 int ecode1 = 0 ;
50115 int val2 ;
50116 int ecode2 = 0 ;
50117 wxGBPosition temp3 ;
50118 wxGBSpan temp4 ;
50119 int val5 ;
50120 int ecode5 = 0 ;
50121 int val6 ;
50122 int ecode6 = 0 ;
50123 PyObject * obj0 = 0 ;
50124 PyObject * obj1 = 0 ;
50125 PyObject * obj2 = 0 ;
50126 PyObject * obj3 = 0 ;
50127 PyObject * obj4 = 0 ;
50128 PyObject * obj5 = 0 ;
50129 PyObject * obj6 = 0 ;
50130 char * kwnames[] = {
50131 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50132 };
50133
50134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50135 ecode1 = SWIG_AsVal_int(obj0, &val1);
50136 if (!SWIG_IsOK(ecode1)) {
50137 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50138 }
50139 arg1 = static_cast< int >(val1);
50140 ecode2 = SWIG_AsVal_int(obj1, &val2);
50141 if (!SWIG_IsOK(ecode2)) {
50142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50143 }
50144 arg2 = static_cast< int >(val2);
50145 {
50146 arg3 = &temp3;
50147 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50148 }
50149 {
50150 arg4 = &temp4;
50151 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50152 }
50153 ecode5 = SWIG_AsVal_int(obj4, &val5);
50154 if (!SWIG_IsOK(ecode5)) {
50155 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50156 }
50157 arg5 = static_cast< int >(val5);
50158 ecode6 = SWIG_AsVal_int(obj5, &val6);
50159 if (!SWIG_IsOK(ecode6)) {
50160 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50161 }
50162 arg6 = static_cast< int >(val6);
50163 if (obj6) {
50164 arg7 = obj6;
50165 }
50166 {
50167 PyThreadState* __tstate = wxPyBeginAllowThreads();
50168 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50169 wxPyEndAllowThreads(__tstate);
50170 if (PyErr_Occurred()) SWIG_fail;
50171 }
50172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50173 return resultobj;
50174 fail:
50175 return NULL;
50176 }
50177
50178
50179 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50180 PyObject *resultobj = 0;
50181 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50182 wxGBPosition result;
50183 void *argp1 = 0 ;
50184 int res1 = 0 ;
50185 PyObject *swig_obj[1] ;
50186
50187 if (!args) SWIG_fail;
50188 swig_obj[0] = args;
50189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50190 if (!SWIG_IsOK(res1)) {
50191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50192 }
50193 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50194 {
50195 PyThreadState* __tstate = wxPyBeginAllowThreads();
50196 result = ((wxGBSizerItem const *)arg1)->GetPos();
50197 wxPyEndAllowThreads(__tstate);
50198 if (PyErr_Occurred()) SWIG_fail;
50199 }
50200 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50201 return resultobj;
50202 fail:
50203 return NULL;
50204 }
50205
50206
50207 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50208 PyObject *resultobj = 0;
50209 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50210 wxGBSpan result;
50211 void *argp1 = 0 ;
50212 int res1 = 0 ;
50213 PyObject *swig_obj[1] ;
50214
50215 if (!args) SWIG_fail;
50216 swig_obj[0] = args;
50217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50218 if (!SWIG_IsOK(res1)) {
50219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50220 }
50221 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50222 {
50223 PyThreadState* __tstate = wxPyBeginAllowThreads();
50224 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50225 wxPyEndAllowThreads(__tstate);
50226 if (PyErr_Occurred()) SWIG_fail;
50227 }
50228 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50229 return resultobj;
50230 fail:
50231 return NULL;
50232 }
50233
50234
50235 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50236 PyObject *resultobj = 0;
50237 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50238 wxGBPosition *arg2 = 0 ;
50239 bool result;
50240 void *argp1 = 0 ;
50241 int res1 = 0 ;
50242 wxGBPosition temp2 ;
50243 PyObject * obj0 = 0 ;
50244 PyObject * obj1 = 0 ;
50245 char * kwnames[] = {
50246 (char *) "self",(char *) "pos", NULL
50247 };
50248
50249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50251 if (!SWIG_IsOK(res1)) {
50252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50253 }
50254 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50255 {
50256 arg2 = &temp2;
50257 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50258 }
50259 {
50260 PyThreadState* __tstate = wxPyBeginAllowThreads();
50261 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50262 wxPyEndAllowThreads(__tstate);
50263 if (PyErr_Occurred()) SWIG_fail;
50264 }
50265 {
50266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50267 }
50268 return resultobj;
50269 fail:
50270 return NULL;
50271 }
50272
50273
50274 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50275 PyObject *resultobj = 0;
50276 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50277 wxGBSpan *arg2 = 0 ;
50278 bool result;
50279 void *argp1 = 0 ;
50280 int res1 = 0 ;
50281 wxGBSpan temp2 ;
50282 PyObject * obj0 = 0 ;
50283 PyObject * obj1 = 0 ;
50284 char * kwnames[] = {
50285 (char *) "self",(char *) "span", NULL
50286 };
50287
50288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50290 if (!SWIG_IsOK(res1)) {
50291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50292 }
50293 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50294 {
50295 arg2 = &temp2;
50296 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50297 }
50298 {
50299 PyThreadState* __tstate = wxPyBeginAllowThreads();
50300 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50301 wxPyEndAllowThreads(__tstate);
50302 if (PyErr_Occurred()) SWIG_fail;
50303 }
50304 {
50305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50306 }
50307 return resultobj;
50308 fail:
50309 return NULL;
50310 }
50311
50312
50313 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50314 PyObject *resultobj = 0;
50315 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50316 wxGBSizerItem *arg2 = 0 ;
50317 bool result;
50318 void *argp1 = 0 ;
50319 int res1 = 0 ;
50320 void *argp2 = 0 ;
50321 int res2 = 0 ;
50322 PyObject * obj0 = 0 ;
50323 PyObject * obj1 = 0 ;
50324 char * kwnames[] = {
50325 (char *) "self",(char *) "other", NULL
50326 };
50327
50328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50330 if (!SWIG_IsOK(res1)) {
50331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50332 }
50333 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50334 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50335 if (!SWIG_IsOK(res2)) {
50336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50337 }
50338 if (!argp2) {
50339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50340 }
50341 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50342 {
50343 PyThreadState* __tstate = wxPyBeginAllowThreads();
50344 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50345 wxPyEndAllowThreads(__tstate);
50346 if (PyErr_Occurred()) SWIG_fail;
50347 }
50348 {
50349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50350 }
50351 return resultobj;
50352 fail:
50353 return NULL;
50354 }
50355
50356
50357 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50358 PyObject *resultobj = 0;
50359 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50360 wxGBPosition *arg2 = 0 ;
50361 wxGBSpan *arg3 = 0 ;
50362 bool result;
50363 void *argp1 = 0 ;
50364 int res1 = 0 ;
50365 wxGBPosition temp2 ;
50366 wxGBSpan temp3 ;
50367 PyObject * obj0 = 0 ;
50368 PyObject * obj1 = 0 ;
50369 PyObject * obj2 = 0 ;
50370 char * kwnames[] = {
50371 (char *) "self",(char *) "pos",(char *) "span", NULL
50372 };
50373
50374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50376 if (!SWIG_IsOK(res1)) {
50377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50378 }
50379 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50380 {
50381 arg2 = &temp2;
50382 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50383 }
50384 {
50385 arg3 = &temp3;
50386 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50387 }
50388 {
50389 PyThreadState* __tstate = wxPyBeginAllowThreads();
50390 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50391 wxPyEndAllowThreads(__tstate);
50392 if (PyErr_Occurred()) SWIG_fail;
50393 }
50394 {
50395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50396 }
50397 return resultobj;
50398 fail:
50399 return NULL;
50400 }
50401
50402
50403 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50404 PyObject *resultobj = 0;
50405 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50406 wxGBPosition result;
50407 void *argp1 = 0 ;
50408 int res1 = 0 ;
50409 PyObject *swig_obj[1] ;
50410
50411 if (!args) SWIG_fail;
50412 swig_obj[0] = args;
50413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50414 if (!SWIG_IsOK(res1)) {
50415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50416 }
50417 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50418 {
50419 PyThreadState* __tstate = wxPyBeginAllowThreads();
50420 result = wxGBSizerItem_GetEndPos(arg1);
50421 wxPyEndAllowThreads(__tstate);
50422 if (PyErr_Occurred()) SWIG_fail;
50423 }
50424 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50425 return resultobj;
50426 fail:
50427 return NULL;
50428 }
50429
50430
50431 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50432 PyObject *resultobj = 0;
50433 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50434 wxGridBagSizer *result = 0 ;
50435 void *argp1 = 0 ;
50436 int res1 = 0 ;
50437 PyObject *swig_obj[1] ;
50438
50439 if (!args) SWIG_fail;
50440 swig_obj[0] = args;
50441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50442 if (!SWIG_IsOK(res1)) {
50443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50444 }
50445 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50446 {
50447 PyThreadState* __tstate = wxPyBeginAllowThreads();
50448 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50449 wxPyEndAllowThreads(__tstate);
50450 if (PyErr_Occurred()) SWIG_fail;
50451 }
50452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50453 return resultobj;
50454 fail:
50455 return NULL;
50456 }
50457
50458
50459 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50460 PyObject *resultobj = 0;
50461 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50462 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50463 void *argp1 = 0 ;
50464 int res1 = 0 ;
50465 void *argp2 = 0 ;
50466 int res2 = 0 ;
50467 PyObject * obj0 = 0 ;
50468 PyObject * obj1 = 0 ;
50469 char * kwnames[] = {
50470 (char *) "self",(char *) "sizer", NULL
50471 };
50472
50473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50475 if (!SWIG_IsOK(res1)) {
50476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50477 }
50478 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50480 if (!SWIG_IsOK(res2)) {
50481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50482 }
50483 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50484 {
50485 PyThreadState* __tstate = wxPyBeginAllowThreads();
50486 (arg1)->SetGBSizer(arg2);
50487 wxPyEndAllowThreads(__tstate);
50488 if (PyErr_Occurred()) SWIG_fail;
50489 }
50490 resultobj = SWIG_Py_Void();
50491 return resultobj;
50492 fail:
50493 return NULL;
50494 }
50495
50496
50497 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50498 PyObject *obj;
50499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50500 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50501 return SWIG_Py_Void();
50502 }
50503
50504 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50505 return SWIG_Python_InitShadowInstance(args);
50506 }
50507
50508 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50509 PyObject *resultobj = 0;
50510 int arg1 = (int) 0 ;
50511 int arg2 = (int) 0 ;
50512 wxGridBagSizer *result = 0 ;
50513 int val1 ;
50514 int ecode1 = 0 ;
50515 int val2 ;
50516 int ecode2 = 0 ;
50517 PyObject * obj0 = 0 ;
50518 PyObject * obj1 = 0 ;
50519 char * kwnames[] = {
50520 (char *) "vgap",(char *) "hgap", NULL
50521 };
50522
50523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50524 if (obj0) {
50525 ecode1 = SWIG_AsVal_int(obj0, &val1);
50526 if (!SWIG_IsOK(ecode1)) {
50527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50528 }
50529 arg1 = static_cast< int >(val1);
50530 }
50531 if (obj1) {
50532 ecode2 = SWIG_AsVal_int(obj1, &val2);
50533 if (!SWIG_IsOK(ecode2)) {
50534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50535 }
50536 arg2 = static_cast< int >(val2);
50537 }
50538 {
50539 PyThreadState* __tstate = wxPyBeginAllowThreads();
50540 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50541 wxPyEndAllowThreads(__tstate);
50542 if (PyErr_Occurred()) SWIG_fail;
50543 }
50544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50552 PyObject *resultobj = 0;
50553 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50554 PyObject *arg2 = (PyObject *) 0 ;
50555 wxGBPosition *arg3 = 0 ;
50556 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50557 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50558 int arg5 = (int) 0 ;
50559 int arg6 = (int) 0 ;
50560 PyObject *arg7 = (PyObject *) NULL ;
50561 wxGBSizerItem *result = 0 ;
50562 void *argp1 = 0 ;
50563 int res1 = 0 ;
50564 wxGBPosition temp3 ;
50565 wxGBSpan temp4 ;
50566 int val5 ;
50567 int ecode5 = 0 ;
50568 int val6 ;
50569 int ecode6 = 0 ;
50570 PyObject * obj0 = 0 ;
50571 PyObject * obj1 = 0 ;
50572 PyObject * obj2 = 0 ;
50573 PyObject * obj3 = 0 ;
50574 PyObject * obj4 = 0 ;
50575 PyObject * obj5 = 0 ;
50576 PyObject * obj6 = 0 ;
50577 char * kwnames[] = {
50578 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50579 };
50580
50581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50583 if (!SWIG_IsOK(res1)) {
50584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50585 }
50586 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50587 arg2 = obj1;
50588 {
50589 arg3 = &temp3;
50590 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50591 }
50592 if (obj3) {
50593 {
50594 arg4 = &temp4;
50595 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50596 }
50597 }
50598 if (obj4) {
50599 ecode5 = SWIG_AsVal_int(obj4, &val5);
50600 if (!SWIG_IsOK(ecode5)) {
50601 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50602 }
50603 arg5 = static_cast< int >(val5);
50604 }
50605 if (obj5) {
50606 ecode6 = SWIG_AsVal_int(obj5, &val6);
50607 if (!SWIG_IsOK(ecode6)) {
50608 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50609 }
50610 arg6 = static_cast< int >(val6);
50611 }
50612 if (obj6) {
50613 arg7 = obj6;
50614 }
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50622 return resultobj;
50623 fail:
50624 return NULL;
50625 }
50626
50627
50628 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50629 PyObject *resultobj = 0;
50630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50631 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50632 wxGBSizerItem *result = 0 ;
50633 void *argp1 = 0 ;
50634 int res1 = 0 ;
50635 int res2 = 0 ;
50636 PyObject * obj0 = 0 ;
50637 PyObject * obj1 = 0 ;
50638 char * kwnames[] = {
50639 (char *) "self",(char *) "item", NULL
50640 };
50641
50642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50648 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50649 if (!SWIG_IsOK(res2)) {
50650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50651 }
50652 {
50653 PyThreadState* __tstate = wxPyBeginAllowThreads();
50654 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50655 wxPyEndAllowThreads(__tstate);
50656 if (PyErr_Occurred()) SWIG_fail;
50657 }
50658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50659 return resultobj;
50660 fail:
50661 return NULL;
50662 }
50663
50664
50665 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50666 PyObject *resultobj = 0;
50667 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50668 int arg2 ;
50669 int arg3 ;
50670 wxSize result;
50671 void *argp1 = 0 ;
50672 int res1 = 0 ;
50673 int val2 ;
50674 int ecode2 = 0 ;
50675 int val3 ;
50676 int ecode3 = 0 ;
50677 PyObject * obj0 = 0 ;
50678 PyObject * obj1 = 0 ;
50679 PyObject * obj2 = 0 ;
50680 char * kwnames[] = {
50681 (char *) "self",(char *) "row",(char *) "col", NULL
50682 };
50683
50684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50686 if (!SWIG_IsOK(res1)) {
50687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50688 }
50689 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50690 ecode2 = SWIG_AsVal_int(obj1, &val2);
50691 if (!SWIG_IsOK(ecode2)) {
50692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50693 }
50694 arg2 = static_cast< int >(val2);
50695 ecode3 = SWIG_AsVal_int(obj2, &val3);
50696 if (!SWIG_IsOK(ecode3)) {
50697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50698 }
50699 arg3 = static_cast< int >(val3);
50700 {
50701 PyThreadState* __tstate = wxPyBeginAllowThreads();
50702 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50703 wxPyEndAllowThreads(__tstate);
50704 if (PyErr_Occurred()) SWIG_fail;
50705 }
50706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50707 return resultobj;
50708 fail:
50709 return NULL;
50710 }
50711
50712
50713 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50714 PyObject *resultobj = 0;
50715 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50716 wxSize result;
50717 void *argp1 = 0 ;
50718 int res1 = 0 ;
50719 PyObject *swig_obj[1] ;
50720
50721 if (!args) SWIG_fail;
50722 swig_obj[0] = args;
50723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50724 if (!SWIG_IsOK(res1)) {
50725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50726 }
50727 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50735 return resultobj;
50736 fail:
50737 return NULL;
50738 }
50739
50740
50741 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50742 PyObject *resultobj = 0;
50743 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50744 wxSize *arg2 = 0 ;
50745 void *argp1 = 0 ;
50746 int res1 = 0 ;
50747 wxSize temp2 ;
50748 PyObject * obj0 = 0 ;
50749 PyObject * obj1 = 0 ;
50750 char * kwnames[] = {
50751 (char *) "self",(char *) "sz", NULL
50752 };
50753
50754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50756 if (!SWIG_IsOK(res1)) {
50757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50758 }
50759 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50760 {
50761 arg2 = &temp2;
50762 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50763 }
50764 {
50765 PyThreadState* __tstate = wxPyBeginAllowThreads();
50766 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50767 wxPyEndAllowThreads(__tstate);
50768 if (PyErr_Occurred()) SWIG_fail;
50769 }
50770 resultobj = SWIG_Py_Void();
50771 return resultobj;
50772 fail:
50773 return NULL;
50774 }
50775
50776
50777 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50778 PyObject *resultobj = 0;
50779 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50780 wxWindow *arg2 = (wxWindow *) 0 ;
50781 wxGBPosition result;
50782 void *argp1 = 0 ;
50783 int res1 = 0 ;
50784 void *argp2 = 0 ;
50785 int res2 = 0 ;
50786
50787 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50789 if (!SWIG_IsOK(res1)) {
50790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50791 }
50792 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50794 if (!SWIG_IsOK(res2)) {
50795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50796 }
50797 arg2 = reinterpret_cast< wxWindow * >(argp2);
50798 {
50799 PyThreadState* __tstate = wxPyBeginAllowThreads();
50800 result = (arg1)->GetItemPosition(arg2);
50801 wxPyEndAllowThreads(__tstate);
50802 if (PyErr_Occurred()) SWIG_fail;
50803 }
50804 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50805 return resultobj;
50806 fail:
50807 return NULL;
50808 }
50809
50810
50811 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50812 PyObject *resultobj = 0;
50813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50814 wxSizer *arg2 = (wxSizer *) 0 ;
50815 wxGBPosition result;
50816 void *argp1 = 0 ;
50817 int res1 = 0 ;
50818 void *argp2 = 0 ;
50819 int res2 = 0 ;
50820
50821 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50823 if (!SWIG_IsOK(res1)) {
50824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50825 }
50826 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50827 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50828 if (!SWIG_IsOK(res2)) {
50829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50830 }
50831 arg2 = reinterpret_cast< wxSizer * >(argp2);
50832 {
50833 PyThreadState* __tstate = wxPyBeginAllowThreads();
50834 result = (arg1)->GetItemPosition(arg2);
50835 wxPyEndAllowThreads(__tstate);
50836 if (PyErr_Occurred()) SWIG_fail;
50837 }
50838 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50839 return resultobj;
50840 fail:
50841 return NULL;
50842 }
50843
50844
50845 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50846 PyObject *resultobj = 0;
50847 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50848 size_t arg2 ;
50849 wxGBPosition result;
50850 void *argp1 = 0 ;
50851 int res1 = 0 ;
50852 size_t val2 ;
50853 int ecode2 = 0 ;
50854
50855 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50857 if (!SWIG_IsOK(res1)) {
50858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50859 }
50860 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50861 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50862 if (!SWIG_IsOK(ecode2)) {
50863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50864 }
50865 arg2 = static_cast< size_t >(val2);
50866 {
50867 PyThreadState* __tstate = wxPyBeginAllowThreads();
50868 result = (arg1)->GetItemPosition(arg2);
50869 wxPyEndAllowThreads(__tstate);
50870 if (PyErr_Occurred()) SWIG_fail;
50871 }
50872 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50873 return resultobj;
50874 fail:
50875 return NULL;
50876 }
50877
50878
50879 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50880 int argc;
50881 PyObject *argv[3];
50882
50883 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50884 --argc;
50885 if (argc == 2) {
50886 int _v = 0;
50887 {
50888 void *vptr = 0;
50889 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50890 _v = SWIG_CheckState(res);
50891 }
50892 if (!_v) goto check_1;
50893 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50894 }
50895 check_1:
50896
50897 if (argc == 2) {
50898 int _v = 0;
50899 {
50900 void *vptr = 0;
50901 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50902 _v = SWIG_CheckState(res);
50903 }
50904 if (!_v) goto check_2;
50905 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50906 }
50907 check_2:
50908
50909 if (argc == 2) {
50910 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50911 }
50912
50913 fail:
50914 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50915 return NULL;
50916 }
50917
50918
50919 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50920 PyObject *resultobj = 0;
50921 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50922 wxWindow *arg2 = (wxWindow *) 0 ;
50923 wxGBPosition *arg3 = 0 ;
50924 bool result;
50925 void *argp1 = 0 ;
50926 int res1 = 0 ;
50927 void *argp2 = 0 ;
50928 int res2 = 0 ;
50929 wxGBPosition temp3 ;
50930
50931 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50937 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50938 if (!SWIG_IsOK(res2)) {
50939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50940 }
50941 arg2 = reinterpret_cast< wxWindow * >(argp2);
50942 {
50943 arg3 = &temp3;
50944 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50945 }
50946 {
50947 PyThreadState* __tstate = wxPyBeginAllowThreads();
50948 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50949 wxPyEndAllowThreads(__tstate);
50950 if (PyErr_Occurred()) SWIG_fail;
50951 }
50952 {
50953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50954 }
50955 return resultobj;
50956 fail:
50957 return NULL;
50958 }
50959
50960
50961 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50962 PyObject *resultobj = 0;
50963 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50964 wxSizer *arg2 = (wxSizer *) 0 ;
50965 wxGBPosition *arg3 = 0 ;
50966 bool result;
50967 void *argp1 = 0 ;
50968 int res1 = 0 ;
50969 void *argp2 = 0 ;
50970 int res2 = 0 ;
50971 wxGBPosition temp3 ;
50972
50973 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50975 if (!SWIG_IsOK(res1)) {
50976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50977 }
50978 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50979 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50980 if (!SWIG_IsOK(res2)) {
50981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50982 }
50983 arg2 = reinterpret_cast< wxSizer * >(argp2);
50984 {
50985 arg3 = &temp3;
50986 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50987 }
50988 {
50989 PyThreadState* __tstate = wxPyBeginAllowThreads();
50990 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50991 wxPyEndAllowThreads(__tstate);
50992 if (PyErr_Occurred()) SWIG_fail;
50993 }
50994 {
50995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50996 }
50997 return resultobj;
50998 fail:
50999 return NULL;
51000 }
51001
51002
51003 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51004 PyObject *resultobj = 0;
51005 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51006 size_t arg2 ;
51007 wxGBPosition *arg3 = 0 ;
51008 bool result;
51009 void *argp1 = 0 ;
51010 int res1 = 0 ;
51011 size_t val2 ;
51012 int ecode2 = 0 ;
51013 wxGBPosition temp3 ;
51014
51015 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51017 if (!SWIG_IsOK(res1)) {
51018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51019 }
51020 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51021 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51022 if (!SWIG_IsOK(ecode2)) {
51023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51024 }
51025 arg2 = static_cast< size_t >(val2);
51026 {
51027 arg3 = &temp3;
51028 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51029 }
51030 {
51031 PyThreadState* __tstate = wxPyBeginAllowThreads();
51032 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51033 wxPyEndAllowThreads(__tstate);
51034 if (PyErr_Occurred()) SWIG_fail;
51035 }
51036 {
51037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51038 }
51039 return resultobj;
51040 fail:
51041 return NULL;
51042 }
51043
51044
51045 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51046 int argc;
51047 PyObject *argv[4];
51048
51049 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51050 --argc;
51051 if (argc == 3) {
51052 int _v = 0;
51053 {
51054 void *vptr = 0;
51055 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51056 _v = SWIG_CheckState(res);
51057 }
51058 if (!_v) goto check_1;
51059 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51060 }
51061 check_1:
51062
51063 if (argc == 3) {
51064 int _v = 0;
51065 {
51066 void *vptr = 0;
51067 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51068 _v = SWIG_CheckState(res);
51069 }
51070 if (!_v) goto check_2;
51071 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51072 }
51073 check_2:
51074
51075 if (argc == 3) {
51076 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51077 }
51078
51079 fail:
51080 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51081 return NULL;
51082 }
51083
51084
51085 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51086 PyObject *resultobj = 0;
51087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51088 wxWindow *arg2 = (wxWindow *) 0 ;
51089 wxGBSpan result;
51090 void *argp1 = 0 ;
51091 int res1 = 0 ;
51092 void *argp2 = 0 ;
51093 int res2 = 0 ;
51094
51095 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51097 if (!SWIG_IsOK(res1)) {
51098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51099 }
51100 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51101 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51102 if (!SWIG_IsOK(res2)) {
51103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51104 }
51105 arg2 = reinterpret_cast< wxWindow * >(argp2);
51106 {
51107 PyThreadState* __tstate = wxPyBeginAllowThreads();
51108 result = (arg1)->GetItemSpan(arg2);
51109 wxPyEndAllowThreads(__tstate);
51110 if (PyErr_Occurred()) SWIG_fail;
51111 }
51112 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51113 return resultobj;
51114 fail:
51115 return NULL;
51116 }
51117
51118
51119 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51120 PyObject *resultobj = 0;
51121 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51122 wxSizer *arg2 = (wxSizer *) 0 ;
51123 wxGBSpan result;
51124 void *argp1 = 0 ;
51125 int res1 = 0 ;
51126 void *argp2 = 0 ;
51127 int res2 = 0 ;
51128
51129 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51131 if (!SWIG_IsOK(res1)) {
51132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51133 }
51134 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51135 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51136 if (!SWIG_IsOK(res2)) {
51137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51138 }
51139 arg2 = reinterpret_cast< wxSizer * >(argp2);
51140 {
51141 PyThreadState* __tstate = wxPyBeginAllowThreads();
51142 result = (arg1)->GetItemSpan(arg2);
51143 wxPyEndAllowThreads(__tstate);
51144 if (PyErr_Occurred()) SWIG_fail;
51145 }
51146 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51147 return resultobj;
51148 fail:
51149 return NULL;
51150 }
51151
51152
51153 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51154 PyObject *resultobj = 0;
51155 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51156 size_t arg2 ;
51157 wxGBSpan result;
51158 void *argp1 = 0 ;
51159 int res1 = 0 ;
51160 size_t val2 ;
51161 int ecode2 = 0 ;
51162
51163 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51165 if (!SWIG_IsOK(res1)) {
51166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51167 }
51168 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51169 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51170 if (!SWIG_IsOK(ecode2)) {
51171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51172 }
51173 arg2 = static_cast< size_t >(val2);
51174 {
51175 PyThreadState* __tstate = wxPyBeginAllowThreads();
51176 result = (arg1)->GetItemSpan(arg2);
51177 wxPyEndAllowThreads(__tstate);
51178 if (PyErr_Occurred()) SWIG_fail;
51179 }
51180 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51181 return resultobj;
51182 fail:
51183 return NULL;
51184 }
51185
51186
51187 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51188 int argc;
51189 PyObject *argv[3];
51190
51191 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51192 --argc;
51193 if (argc == 2) {
51194 int _v = 0;
51195 {
51196 void *vptr = 0;
51197 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51198 _v = SWIG_CheckState(res);
51199 }
51200 if (!_v) goto check_1;
51201 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51202 }
51203 check_1:
51204
51205 if (argc == 2) {
51206 int _v = 0;
51207 {
51208 void *vptr = 0;
51209 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51210 _v = SWIG_CheckState(res);
51211 }
51212 if (!_v) goto check_2;
51213 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51214 }
51215 check_2:
51216
51217 if (argc == 2) {
51218 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51219 }
51220
51221 fail:
51222 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51223 return NULL;
51224 }
51225
51226
51227 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51228 PyObject *resultobj = 0;
51229 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51230 wxWindow *arg2 = (wxWindow *) 0 ;
51231 wxGBSpan *arg3 = 0 ;
51232 bool result;
51233 void *argp1 = 0 ;
51234 int res1 = 0 ;
51235 void *argp2 = 0 ;
51236 int res2 = 0 ;
51237 wxGBSpan temp3 ;
51238
51239 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51241 if (!SWIG_IsOK(res1)) {
51242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51243 }
51244 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51246 if (!SWIG_IsOK(res2)) {
51247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51248 }
51249 arg2 = reinterpret_cast< wxWindow * >(argp2);
51250 {
51251 arg3 = &temp3;
51252 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51253 }
51254 {
51255 PyThreadState* __tstate = wxPyBeginAllowThreads();
51256 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51257 wxPyEndAllowThreads(__tstate);
51258 if (PyErr_Occurred()) SWIG_fail;
51259 }
51260 {
51261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51262 }
51263 return resultobj;
51264 fail:
51265 return NULL;
51266 }
51267
51268
51269 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51270 PyObject *resultobj = 0;
51271 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51272 wxSizer *arg2 = (wxSizer *) 0 ;
51273 wxGBSpan *arg3 = 0 ;
51274 bool result;
51275 void *argp1 = 0 ;
51276 int res1 = 0 ;
51277 void *argp2 = 0 ;
51278 int res2 = 0 ;
51279 wxGBSpan temp3 ;
51280
51281 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51283 if (!SWIG_IsOK(res1)) {
51284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51285 }
51286 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51287 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51288 if (!SWIG_IsOK(res2)) {
51289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51290 }
51291 arg2 = reinterpret_cast< wxSizer * >(argp2);
51292 {
51293 arg3 = &temp3;
51294 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51295 }
51296 {
51297 PyThreadState* __tstate = wxPyBeginAllowThreads();
51298 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51299 wxPyEndAllowThreads(__tstate);
51300 if (PyErr_Occurred()) SWIG_fail;
51301 }
51302 {
51303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51304 }
51305 return resultobj;
51306 fail:
51307 return NULL;
51308 }
51309
51310
51311 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51312 PyObject *resultobj = 0;
51313 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51314 size_t arg2 ;
51315 wxGBSpan *arg3 = 0 ;
51316 bool result;
51317 void *argp1 = 0 ;
51318 int res1 = 0 ;
51319 size_t val2 ;
51320 int ecode2 = 0 ;
51321 wxGBSpan temp3 ;
51322
51323 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51325 if (!SWIG_IsOK(res1)) {
51326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51327 }
51328 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51329 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51330 if (!SWIG_IsOK(ecode2)) {
51331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51332 }
51333 arg2 = static_cast< size_t >(val2);
51334 {
51335 arg3 = &temp3;
51336 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51337 }
51338 {
51339 PyThreadState* __tstate = wxPyBeginAllowThreads();
51340 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51341 wxPyEndAllowThreads(__tstate);
51342 if (PyErr_Occurred()) SWIG_fail;
51343 }
51344 {
51345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51346 }
51347 return resultobj;
51348 fail:
51349 return NULL;
51350 }
51351
51352
51353 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51354 int argc;
51355 PyObject *argv[4];
51356
51357 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51358 --argc;
51359 if (argc == 3) {
51360 int _v = 0;
51361 {
51362 void *vptr = 0;
51363 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51364 _v = SWIG_CheckState(res);
51365 }
51366 if (!_v) goto check_1;
51367 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51368 }
51369 check_1:
51370
51371 if (argc == 3) {
51372 int _v = 0;
51373 {
51374 void *vptr = 0;
51375 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51376 _v = SWIG_CheckState(res);
51377 }
51378 if (!_v) goto check_2;
51379 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51380 }
51381 check_2:
51382
51383 if (argc == 3) {
51384 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51385 }
51386
51387 fail:
51388 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51389 return NULL;
51390 }
51391
51392
51393 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51394 PyObject *resultobj = 0;
51395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51396 wxWindow *arg2 = (wxWindow *) 0 ;
51397 wxGBSizerItem *result = 0 ;
51398 void *argp1 = 0 ;
51399 int res1 = 0 ;
51400 void *argp2 = 0 ;
51401 int res2 = 0 ;
51402
51403 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51405 if (!SWIG_IsOK(res1)) {
51406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51407 }
51408 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51409 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51410 if (!SWIG_IsOK(res2)) {
51411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51412 }
51413 arg2 = reinterpret_cast< wxWindow * >(argp2);
51414 {
51415 PyThreadState* __tstate = wxPyBeginAllowThreads();
51416 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51417 wxPyEndAllowThreads(__tstate);
51418 if (PyErr_Occurred()) SWIG_fail;
51419 }
51420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51421 return resultobj;
51422 fail:
51423 return NULL;
51424 }
51425
51426
51427 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51428 PyObject *resultobj = 0;
51429 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51430 wxSizer *arg2 = (wxSizer *) 0 ;
51431 wxGBSizerItem *result = 0 ;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 void *argp2 = 0 ;
51435 int res2 = 0 ;
51436
51437 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51441 }
51442 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51444 if (!SWIG_IsOK(res2)) {
51445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51446 }
51447 arg2 = reinterpret_cast< wxSizer * >(argp2);
51448 {
51449 PyThreadState* __tstate = wxPyBeginAllowThreads();
51450 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51451 wxPyEndAllowThreads(__tstate);
51452 if (PyErr_Occurred()) SWIG_fail;
51453 }
51454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51455 return resultobj;
51456 fail:
51457 return NULL;
51458 }
51459
51460
51461 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51462 int argc;
51463 PyObject *argv[3];
51464
51465 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51466 --argc;
51467 if (argc == 2) {
51468 int _v = 0;
51469 {
51470 void *vptr = 0;
51471 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51472 _v = SWIG_CheckState(res);
51473 }
51474 if (!_v) goto check_1;
51475 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51476 }
51477 check_1:
51478
51479 if (argc == 2) {
51480 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51481 }
51482
51483 fail:
51484 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51485 return NULL;
51486 }
51487
51488
51489 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51490 PyObject *resultobj = 0;
51491 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51492 wxGBPosition *arg2 = 0 ;
51493 wxGBSizerItem *result = 0 ;
51494 void *argp1 = 0 ;
51495 int res1 = 0 ;
51496 wxGBPosition temp2 ;
51497 PyObject * obj0 = 0 ;
51498 PyObject * obj1 = 0 ;
51499 char * kwnames[] = {
51500 (char *) "self",(char *) "pos", NULL
51501 };
51502
51503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51505 if (!SWIG_IsOK(res1)) {
51506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51507 }
51508 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51509 {
51510 arg2 = &temp2;
51511 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51512 }
51513 {
51514 PyThreadState* __tstate = wxPyBeginAllowThreads();
51515 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51516 wxPyEndAllowThreads(__tstate);
51517 if (PyErr_Occurred()) SWIG_fail;
51518 }
51519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51520 return resultobj;
51521 fail:
51522 return NULL;
51523 }
51524
51525
51526 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51527 PyObject *resultobj = 0;
51528 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51529 wxPoint *arg2 = 0 ;
51530 wxGBSizerItem *result = 0 ;
51531 void *argp1 = 0 ;
51532 int res1 = 0 ;
51533 wxPoint temp2 ;
51534 PyObject * obj0 = 0 ;
51535 PyObject * obj1 = 0 ;
51536 char * kwnames[] = {
51537 (char *) "self",(char *) "pt", NULL
51538 };
51539
51540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51542 if (!SWIG_IsOK(res1)) {
51543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51544 }
51545 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51546 {
51547 arg2 = &temp2;
51548 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51549 }
51550 {
51551 PyThreadState* __tstate = wxPyBeginAllowThreads();
51552 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51553 wxPyEndAllowThreads(__tstate);
51554 if (PyErr_Occurred()) SWIG_fail;
51555 }
51556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51557 return resultobj;
51558 fail:
51559 return NULL;
51560 }
51561
51562
51563 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51564 PyObject *resultobj = 0;
51565 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51566 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51567 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51568 bool result;
51569 void *argp1 = 0 ;
51570 int res1 = 0 ;
51571 void *argp2 = 0 ;
51572 int res2 = 0 ;
51573 void *argp3 = 0 ;
51574 int res3 = 0 ;
51575 PyObject * obj0 = 0 ;
51576 PyObject * obj1 = 0 ;
51577 PyObject * obj2 = 0 ;
51578 char * kwnames[] = {
51579 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51580 };
51581
51582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51584 if (!SWIG_IsOK(res1)) {
51585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51586 }
51587 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51589 if (!SWIG_IsOK(res2)) {
51590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51591 }
51592 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51593 if (obj2) {
51594 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51595 if (!SWIG_IsOK(res3)) {
51596 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51597 }
51598 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51599 }
51600 {
51601 PyThreadState* __tstate = wxPyBeginAllowThreads();
51602 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51603 wxPyEndAllowThreads(__tstate);
51604 if (PyErr_Occurred()) SWIG_fail;
51605 }
51606 {
51607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51608 }
51609 return resultobj;
51610 fail:
51611 return NULL;
51612 }
51613
51614
51615 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51616 PyObject *resultobj = 0;
51617 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51618 wxGBPosition *arg2 = 0 ;
51619 wxGBSpan *arg3 = 0 ;
51620 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51621 bool result;
51622 void *argp1 = 0 ;
51623 int res1 = 0 ;
51624 wxGBPosition temp2 ;
51625 wxGBSpan temp3 ;
51626 void *argp4 = 0 ;
51627 int res4 = 0 ;
51628 PyObject * obj0 = 0 ;
51629 PyObject * obj1 = 0 ;
51630 PyObject * obj2 = 0 ;
51631 PyObject * obj3 = 0 ;
51632 char * kwnames[] = {
51633 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51634 };
51635
51636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51638 if (!SWIG_IsOK(res1)) {
51639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51640 }
51641 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51642 {
51643 arg2 = &temp2;
51644 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51645 }
51646 {
51647 arg3 = &temp3;
51648 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51649 }
51650 if (obj3) {
51651 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51652 if (!SWIG_IsOK(res4)) {
51653 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51654 }
51655 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51656 }
51657 {
51658 PyThreadState* __tstate = wxPyBeginAllowThreads();
51659 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51660 wxPyEndAllowThreads(__tstate);
51661 if (PyErr_Occurred()) SWIG_fail;
51662 }
51663 {
51664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51665 }
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51673 PyObject *obj;
51674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51675 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51676 return SWIG_Py_Void();
51677 }
51678
51679 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51680 return SWIG_Python_InitShadowInstance(args);
51681 }
51682
51683 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51684 PyObject *resultobj = 0;
51685 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51686 wxRelationship arg2 ;
51687 wxWindow *arg3 = (wxWindow *) 0 ;
51688 wxEdge arg4 ;
51689 int arg5 = (int) 0 ;
51690 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51691 void *argp1 = 0 ;
51692 int res1 = 0 ;
51693 int val2 ;
51694 int ecode2 = 0 ;
51695 void *argp3 = 0 ;
51696 int res3 = 0 ;
51697 int val4 ;
51698 int ecode4 = 0 ;
51699 int val5 ;
51700 int ecode5 = 0 ;
51701 int val6 ;
51702 int ecode6 = 0 ;
51703 PyObject * obj0 = 0 ;
51704 PyObject * obj1 = 0 ;
51705 PyObject * obj2 = 0 ;
51706 PyObject * obj3 = 0 ;
51707 PyObject * obj4 = 0 ;
51708 PyObject * obj5 = 0 ;
51709 char * kwnames[] = {
51710 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51711 };
51712
51713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51715 if (!SWIG_IsOK(res1)) {
51716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51717 }
51718 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51719 ecode2 = SWIG_AsVal_int(obj1, &val2);
51720 if (!SWIG_IsOK(ecode2)) {
51721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51722 }
51723 arg2 = static_cast< wxRelationship >(val2);
51724 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51725 if (!SWIG_IsOK(res3)) {
51726 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51727 }
51728 arg3 = reinterpret_cast< wxWindow * >(argp3);
51729 ecode4 = SWIG_AsVal_int(obj3, &val4);
51730 if (!SWIG_IsOK(ecode4)) {
51731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51732 }
51733 arg4 = static_cast< wxEdge >(val4);
51734 if (obj4) {
51735 ecode5 = SWIG_AsVal_int(obj4, &val5);
51736 if (!SWIG_IsOK(ecode5)) {
51737 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51738 }
51739 arg5 = static_cast< int >(val5);
51740 }
51741 if (obj5) {
51742 ecode6 = SWIG_AsVal_int(obj5, &val6);
51743 if (!SWIG_IsOK(ecode6)) {
51744 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51745 }
51746 arg6 = static_cast< int >(val6);
51747 }
51748 {
51749 PyThreadState* __tstate = wxPyBeginAllowThreads();
51750 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51751 wxPyEndAllowThreads(__tstate);
51752 if (PyErr_Occurred()) SWIG_fail;
51753 }
51754 resultobj = SWIG_Py_Void();
51755 return resultobj;
51756 fail:
51757 return NULL;
51758 }
51759
51760
51761 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51762 PyObject *resultobj = 0;
51763 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51764 wxWindow *arg2 = (wxWindow *) 0 ;
51765 int arg3 = (int) 0 ;
51766 void *argp1 = 0 ;
51767 int res1 = 0 ;
51768 void *argp2 = 0 ;
51769 int res2 = 0 ;
51770 int val3 ;
51771 int ecode3 = 0 ;
51772 PyObject * obj0 = 0 ;
51773 PyObject * obj1 = 0 ;
51774 PyObject * obj2 = 0 ;
51775 char * kwnames[] = {
51776 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51777 };
51778
51779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51781 if (!SWIG_IsOK(res1)) {
51782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51783 }
51784 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51786 if (!SWIG_IsOK(res2)) {
51787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51788 }
51789 arg2 = reinterpret_cast< wxWindow * >(argp2);
51790 if (obj2) {
51791 ecode3 = SWIG_AsVal_int(obj2, &val3);
51792 if (!SWIG_IsOK(ecode3)) {
51793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51794 }
51795 arg3 = static_cast< int >(val3);
51796 }
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 (arg1)->LeftOf(arg2,arg3);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_Py_Void();
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51811 PyObject *resultobj = 0;
51812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51813 wxWindow *arg2 = (wxWindow *) 0 ;
51814 int arg3 = (int) 0 ;
51815 void *argp1 = 0 ;
51816 int res1 = 0 ;
51817 void *argp2 = 0 ;
51818 int res2 = 0 ;
51819 int val3 ;
51820 int ecode3 = 0 ;
51821 PyObject * obj0 = 0 ;
51822 PyObject * obj1 = 0 ;
51823 PyObject * obj2 = 0 ;
51824 char * kwnames[] = {
51825 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51826 };
51827
51828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51830 if (!SWIG_IsOK(res1)) {
51831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51832 }
51833 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51835 if (!SWIG_IsOK(res2)) {
51836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51837 }
51838 arg2 = reinterpret_cast< wxWindow * >(argp2);
51839 if (obj2) {
51840 ecode3 = SWIG_AsVal_int(obj2, &val3);
51841 if (!SWIG_IsOK(ecode3)) {
51842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51843 }
51844 arg3 = static_cast< int >(val3);
51845 }
51846 {
51847 PyThreadState* __tstate = wxPyBeginAllowThreads();
51848 (arg1)->RightOf(arg2,arg3);
51849 wxPyEndAllowThreads(__tstate);
51850 if (PyErr_Occurred()) SWIG_fail;
51851 }
51852 resultobj = SWIG_Py_Void();
51853 return resultobj;
51854 fail:
51855 return NULL;
51856 }
51857
51858
51859 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51860 PyObject *resultobj = 0;
51861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51862 wxWindow *arg2 = (wxWindow *) 0 ;
51863 int arg3 = (int) 0 ;
51864 void *argp1 = 0 ;
51865 int res1 = 0 ;
51866 void *argp2 = 0 ;
51867 int res2 = 0 ;
51868 int val3 ;
51869 int ecode3 = 0 ;
51870 PyObject * obj0 = 0 ;
51871 PyObject * obj1 = 0 ;
51872 PyObject * obj2 = 0 ;
51873 char * kwnames[] = {
51874 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51875 };
51876
51877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51879 if (!SWIG_IsOK(res1)) {
51880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51881 }
51882 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51884 if (!SWIG_IsOK(res2)) {
51885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51886 }
51887 arg2 = reinterpret_cast< wxWindow * >(argp2);
51888 if (obj2) {
51889 ecode3 = SWIG_AsVal_int(obj2, &val3);
51890 if (!SWIG_IsOK(ecode3)) {
51891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51892 }
51893 arg3 = static_cast< int >(val3);
51894 }
51895 {
51896 PyThreadState* __tstate = wxPyBeginAllowThreads();
51897 (arg1)->Above(arg2,arg3);
51898 wxPyEndAllowThreads(__tstate);
51899 if (PyErr_Occurred()) SWIG_fail;
51900 }
51901 resultobj = SWIG_Py_Void();
51902 return resultobj;
51903 fail:
51904 return NULL;
51905 }
51906
51907
51908 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51909 PyObject *resultobj = 0;
51910 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51911 wxWindow *arg2 = (wxWindow *) 0 ;
51912 int arg3 = (int) 0 ;
51913 void *argp1 = 0 ;
51914 int res1 = 0 ;
51915 void *argp2 = 0 ;
51916 int res2 = 0 ;
51917 int val3 ;
51918 int ecode3 = 0 ;
51919 PyObject * obj0 = 0 ;
51920 PyObject * obj1 = 0 ;
51921 PyObject * obj2 = 0 ;
51922 char * kwnames[] = {
51923 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51924 };
51925
51926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51928 if (!SWIG_IsOK(res1)) {
51929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51930 }
51931 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51933 if (!SWIG_IsOK(res2)) {
51934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51935 }
51936 arg2 = reinterpret_cast< wxWindow * >(argp2);
51937 if (obj2) {
51938 ecode3 = SWIG_AsVal_int(obj2, &val3);
51939 if (!SWIG_IsOK(ecode3)) {
51940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51941 }
51942 arg3 = static_cast< int >(val3);
51943 }
51944 {
51945 PyThreadState* __tstate = wxPyBeginAllowThreads();
51946 (arg1)->Below(arg2,arg3);
51947 wxPyEndAllowThreads(__tstate);
51948 if (PyErr_Occurred()) SWIG_fail;
51949 }
51950 resultobj = SWIG_Py_Void();
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51958 PyObject *resultobj = 0;
51959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51960 wxWindow *arg2 = (wxWindow *) 0 ;
51961 wxEdge arg3 ;
51962 int arg4 = (int) 0 ;
51963 void *argp1 = 0 ;
51964 int res1 = 0 ;
51965 void *argp2 = 0 ;
51966 int res2 = 0 ;
51967 int val3 ;
51968 int ecode3 = 0 ;
51969 int val4 ;
51970 int ecode4 = 0 ;
51971 PyObject * obj0 = 0 ;
51972 PyObject * obj1 = 0 ;
51973 PyObject * obj2 = 0 ;
51974 PyObject * obj3 = 0 ;
51975 char * kwnames[] = {
51976 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51977 };
51978
51979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51981 if (!SWIG_IsOK(res1)) {
51982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51983 }
51984 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51986 if (!SWIG_IsOK(res2)) {
51987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51988 }
51989 arg2 = reinterpret_cast< wxWindow * >(argp2);
51990 ecode3 = SWIG_AsVal_int(obj2, &val3);
51991 if (!SWIG_IsOK(ecode3)) {
51992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51993 }
51994 arg3 = static_cast< wxEdge >(val3);
51995 if (obj3) {
51996 ecode4 = SWIG_AsVal_int(obj3, &val4);
51997 if (!SWIG_IsOK(ecode4)) {
51998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51999 }
52000 arg4 = static_cast< int >(val4);
52001 }
52002 {
52003 PyThreadState* __tstate = wxPyBeginAllowThreads();
52004 (arg1)->SameAs(arg2,arg3,arg4);
52005 wxPyEndAllowThreads(__tstate);
52006 if (PyErr_Occurred()) SWIG_fail;
52007 }
52008 resultobj = SWIG_Py_Void();
52009 return resultobj;
52010 fail:
52011 return NULL;
52012 }
52013
52014
52015 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52016 PyObject *resultobj = 0;
52017 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52018 wxWindow *arg2 = (wxWindow *) 0 ;
52019 wxEdge arg3 ;
52020 int arg4 ;
52021 void *argp1 = 0 ;
52022 int res1 = 0 ;
52023 void *argp2 = 0 ;
52024 int res2 = 0 ;
52025 int val3 ;
52026 int ecode3 = 0 ;
52027 int val4 ;
52028 int ecode4 = 0 ;
52029 PyObject * obj0 = 0 ;
52030 PyObject * obj1 = 0 ;
52031 PyObject * obj2 = 0 ;
52032 PyObject * obj3 = 0 ;
52033 char * kwnames[] = {
52034 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52035 };
52036
52037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52041 }
52042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52044 if (!SWIG_IsOK(res2)) {
52045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52046 }
52047 arg2 = reinterpret_cast< wxWindow * >(argp2);
52048 ecode3 = SWIG_AsVal_int(obj2, &val3);
52049 if (!SWIG_IsOK(ecode3)) {
52050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52051 }
52052 arg3 = static_cast< wxEdge >(val3);
52053 ecode4 = SWIG_AsVal_int(obj3, &val4);
52054 if (!SWIG_IsOK(ecode4)) {
52055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52056 }
52057 arg4 = static_cast< int >(val4);
52058 {
52059 PyThreadState* __tstate = wxPyBeginAllowThreads();
52060 (arg1)->PercentOf(arg2,arg3,arg4);
52061 wxPyEndAllowThreads(__tstate);
52062 if (PyErr_Occurred()) SWIG_fail;
52063 }
52064 resultobj = SWIG_Py_Void();
52065 return resultobj;
52066 fail:
52067 return NULL;
52068 }
52069
52070
52071 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52072 PyObject *resultobj = 0;
52073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52074 int arg2 ;
52075 void *argp1 = 0 ;
52076 int res1 = 0 ;
52077 int val2 ;
52078 int ecode2 = 0 ;
52079 PyObject * obj0 = 0 ;
52080 PyObject * obj1 = 0 ;
52081 char * kwnames[] = {
52082 (char *) "self",(char *) "val", NULL
52083 };
52084
52085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52087 if (!SWIG_IsOK(res1)) {
52088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52089 }
52090 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52091 ecode2 = SWIG_AsVal_int(obj1, &val2);
52092 if (!SWIG_IsOK(ecode2)) {
52093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52094 }
52095 arg2 = static_cast< int >(val2);
52096 {
52097 PyThreadState* __tstate = wxPyBeginAllowThreads();
52098 (arg1)->Absolute(arg2);
52099 wxPyEndAllowThreads(__tstate);
52100 if (PyErr_Occurred()) SWIG_fail;
52101 }
52102 resultobj = SWIG_Py_Void();
52103 return resultobj;
52104 fail:
52105 return NULL;
52106 }
52107
52108
52109 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52110 PyObject *resultobj = 0;
52111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52112 void *argp1 = 0 ;
52113 int res1 = 0 ;
52114 PyObject *swig_obj[1] ;
52115
52116 if (!args) SWIG_fail;
52117 swig_obj[0] = args;
52118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52119 if (!SWIG_IsOK(res1)) {
52120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52121 }
52122 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52123 {
52124 PyThreadState* __tstate = wxPyBeginAllowThreads();
52125 (arg1)->Unconstrained();
52126 wxPyEndAllowThreads(__tstate);
52127 if (PyErr_Occurred()) SWIG_fail;
52128 }
52129 resultobj = SWIG_Py_Void();
52130 return resultobj;
52131 fail:
52132 return NULL;
52133 }
52134
52135
52136 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52137 PyObject *resultobj = 0;
52138 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52139 void *argp1 = 0 ;
52140 int res1 = 0 ;
52141 PyObject *swig_obj[1] ;
52142
52143 if (!args) SWIG_fail;
52144 swig_obj[0] = args;
52145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52146 if (!SWIG_IsOK(res1)) {
52147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52148 }
52149 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52150 {
52151 PyThreadState* __tstate = wxPyBeginAllowThreads();
52152 (arg1)->AsIs();
52153 wxPyEndAllowThreads(__tstate);
52154 if (PyErr_Occurred()) SWIG_fail;
52155 }
52156 resultobj = SWIG_Py_Void();
52157 return resultobj;
52158 fail:
52159 return NULL;
52160 }
52161
52162
52163 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52164 PyObject *resultobj = 0;
52165 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52166 wxWindow *result = 0 ;
52167 void *argp1 = 0 ;
52168 int res1 = 0 ;
52169 PyObject *swig_obj[1] ;
52170
52171 if (!args) SWIG_fail;
52172 swig_obj[0] = args;
52173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52174 if (!SWIG_IsOK(res1)) {
52175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52176 }
52177 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52178 {
52179 PyThreadState* __tstate = wxPyBeginAllowThreads();
52180 result = (wxWindow *)(arg1)->GetOtherWindow();
52181 wxPyEndAllowThreads(__tstate);
52182 if (PyErr_Occurred()) SWIG_fail;
52183 }
52184 {
52185 resultobj = wxPyMake_wxObject(result, 0);
52186 }
52187 return resultobj;
52188 fail:
52189 return NULL;
52190 }
52191
52192
52193 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52194 PyObject *resultobj = 0;
52195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52196 wxEdge result;
52197 void *argp1 = 0 ;
52198 int res1 = 0 ;
52199 PyObject *swig_obj[1] ;
52200
52201 if (!args) SWIG_fail;
52202 swig_obj[0] = args;
52203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52204 if (!SWIG_IsOK(res1)) {
52205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52206 }
52207 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52208 {
52209 PyThreadState* __tstate = wxPyBeginAllowThreads();
52210 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52211 wxPyEndAllowThreads(__tstate);
52212 if (PyErr_Occurred()) SWIG_fail;
52213 }
52214 resultobj = SWIG_From_int(static_cast< int >(result));
52215 return resultobj;
52216 fail:
52217 return NULL;
52218 }
52219
52220
52221 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52222 PyObject *resultobj = 0;
52223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52224 wxEdge arg2 ;
52225 void *argp1 = 0 ;
52226 int res1 = 0 ;
52227 int val2 ;
52228 int ecode2 = 0 ;
52229 PyObject * obj0 = 0 ;
52230 PyObject * obj1 = 0 ;
52231 char * kwnames[] = {
52232 (char *) "self",(char *) "which", NULL
52233 };
52234
52235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52237 if (!SWIG_IsOK(res1)) {
52238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52239 }
52240 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52241 ecode2 = SWIG_AsVal_int(obj1, &val2);
52242 if (!SWIG_IsOK(ecode2)) {
52243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52244 }
52245 arg2 = static_cast< wxEdge >(val2);
52246 {
52247 PyThreadState* __tstate = wxPyBeginAllowThreads();
52248 (arg1)->SetEdge(arg2);
52249 wxPyEndAllowThreads(__tstate);
52250 if (PyErr_Occurred()) SWIG_fail;
52251 }
52252 resultobj = SWIG_Py_Void();
52253 return resultobj;
52254 fail:
52255 return NULL;
52256 }
52257
52258
52259 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52260 PyObject *resultobj = 0;
52261 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52262 int arg2 ;
52263 void *argp1 = 0 ;
52264 int res1 = 0 ;
52265 int val2 ;
52266 int ecode2 = 0 ;
52267 PyObject * obj0 = 0 ;
52268 PyObject * obj1 = 0 ;
52269 char * kwnames[] = {
52270 (char *) "self",(char *) "v", NULL
52271 };
52272
52273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52275 if (!SWIG_IsOK(res1)) {
52276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52277 }
52278 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52279 ecode2 = SWIG_AsVal_int(obj1, &val2);
52280 if (!SWIG_IsOK(ecode2)) {
52281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52282 }
52283 arg2 = static_cast< int >(val2);
52284 {
52285 PyThreadState* __tstate = wxPyBeginAllowThreads();
52286 (arg1)->SetValue(arg2);
52287 wxPyEndAllowThreads(__tstate);
52288 if (PyErr_Occurred()) SWIG_fail;
52289 }
52290 resultobj = SWIG_Py_Void();
52291 return resultobj;
52292 fail:
52293 return NULL;
52294 }
52295
52296
52297 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52298 PyObject *resultobj = 0;
52299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52300 int result;
52301 void *argp1 = 0 ;
52302 int res1 = 0 ;
52303 PyObject *swig_obj[1] ;
52304
52305 if (!args) SWIG_fail;
52306 swig_obj[0] = args;
52307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52308 if (!SWIG_IsOK(res1)) {
52309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52310 }
52311 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52312 {
52313 PyThreadState* __tstate = wxPyBeginAllowThreads();
52314 result = (int)(arg1)->GetMargin();
52315 wxPyEndAllowThreads(__tstate);
52316 if (PyErr_Occurred()) SWIG_fail;
52317 }
52318 resultobj = SWIG_From_int(static_cast< int >(result));
52319 return resultobj;
52320 fail:
52321 return NULL;
52322 }
52323
52324
52325 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52326 PyObject *resultobj = 0;
52327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52328 int arg2 ;
52329 void *argp1 = 0 ;
52330 int res1 = 0 ;
52331 int val2 ;
52332 int ecode2 = 0 ;
52333 PyObject * obj0 = 0 ;
52334 PyObject * obj1 = 0 ;
52335 char * kwnames[] = {
52336 (char *) "self",(char *) "m", NULL
52337 };
52338
52339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52341 if (!SWIG_IsOK(res1)) {
52342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52343 }
52344 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52345 ecode2 = SWIG_AsVal_int(obj1, &val2);
52346 if (!SWIG_IsOK(ecode2)) {
52347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52348 }
52349 arg2 = static_cast< int >(val2);
52350 {
52351 PyThreadState* __tstate = wxPyBeginAllowThreads();
52352 (arg1)->SetMargin(arg2);
52353 wxPyEndAllowThreads(__tstate);
52354 if (PyErr_Occurred()) SWIG_fail;
52355 }
52356 resultobj = SWIG_Py_Void();
52357 return resultobj;
52358 fail:
52359 return NULL;
52360 }
52361
52362
52363 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52364 PyObject *resultobj = 0;
52365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52366 int result;
52367 void *argp1 = 0 ;
52368 int res1 = 0 ;
52369 PyObject *swig_obj[1] ;
52370
52371 if (!args) SWIG_fail;
52372 swig_obj[0] = args;
52373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52374 if (!SWIG_IsOK(res1)) {
52375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52376 }
52377 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52378 {
52379 PyThreadState* __tstate = wxPyBeginAllowThreads();
52380 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52381 wxPyEndAllowThreads(__tstate);
52382 if (PyErr_Occurred()) SWIG_fail;
52383 }
52384 resultobj = SWIG_From_int(static_cast< int >(result));
52385 return resultobj;
52386 fail:
52387 return NULL;
52388 }
52389
52390
52391 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52392 PyObject *resultobj = 0;
52393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52394 int result;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 PyObject *swig_obj[1] ;
52398
52399 if (!args) SWIG_fail;
52400 swig_obj[0] = args;
52401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52402 if (!SWIG_IsOK(res1)) {
52403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52404 }
52405 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52406 {
52407 PyThreadState* __tstate = wxPyBeginAllowThreads();
52408 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52409 wxPyEndAllowThreads(__tstate);
52410 if (PyErr_Occurred()) SWIG_fail;
52411 }
52412 resultobj = SWIG_From_int(static_cast< int >(result));
52413 return resultobj;
52414 fail:
52415 return NULL;
52416 }
52417
52418
52419 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52420 PyObject *resultobj = 0;
52421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52422 int result;
52423 void *argp1 = 0 ;
52424 int res1 = 0 ;
52425 PyObject *swig_obj[1] ;
52426
52427 if (!args) SWIG_fail;
52428 swig_obj[0] = args;
52429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52430 if (!SWIG_IsOK(res1)) {
52431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52432 }
52433 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52434 {
52435 PyThreadState* __tstate = wxPyBeginAllowThreads();
52436 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52437 wxPyEndAllowThreads(__tstate);
52438 if (PyErr_Occurred()) SWIG_fail;
52439 }
52440 resultobj = SWIG_From_int(static_cast< int >(result));
52441 return resultobj;
52442 fail:
52443 return NULL;
52444 }
52445
52446
52447 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52448 PyObject *resultobj = 0;
52449 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52450 bool result;
52451 void *argp1 = 0 ;
52452 int res1 = 0 ;
52453 PyObject *swig_obj[1] ;
52454
52455 if (!args) SWIG_fail;
52456 swig_obj[0] = args;
52457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52458 if (!SWIG_IsOK(res1)) {
52459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52460 }
52461 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52462 {
52463 PyThreadState* __tstate = wxPyBeginAllowThreads();
52464 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52465 wxPyEndAllowThreads(__tstate);
52466 if (PyErr_Occurred()) SWIG_fail;
52467 }
52468 {
52469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52470 }
52471 return resultobj;
52472 fail:
52473 return NULL;
52474 }
52475
52476
52477 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52478 PyObject *resultobj = 0;
52479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52480 bool arg2 ;
52481 void *argp1 = 0 ;
52482 int res1 = 0 ;
52483 bool val2 ;
52484 int ecode2 = 0 ;
52485 PyObject * obj0 = 0 ;
52486 PyObject * obj1 = 0 ;
52487 char * kwnames[] = {
52488 (char *) "self",(char *) "d", NULL
52489 };
52490
52491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52495 }
52496 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52498 if (!SWIG_IsOK(ecode2)) {
52499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52500 }
52501 arg2 = static_cast< bool >(val2);
52502 {
52503 PyThreadState* __tstate = wxPyBeginAllowThreads();
52504 (arg1)->SetDone(arg2);
52505 wxPyEndAllowThreads(__tstate);
52506 if (PyErr_Occurred()) SWIG_fail;
52507 }
52508 resultobj = SWIG_Py_Void();
52509 return resultobj;
52510 fail:
52511 return NULL;
52512 }
52513
52514
52515 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52516 PyObject *resultobj = 0;
52517 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52518 wxRelationship result;
52519 void *argp1 = 0 ;
52520 int res1 = 0 ;
52521 PyObject *swig_obj[1] ;
52522
52523 if (!args) SWIG_fail;
52524 swig_obj[0] = args;
52525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52526 if (!SWIG_IsOK(res1)) {
52527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52528 }
52529 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52530 {
52531 PyThreadState* __tstate = wxPyBeginAllowThreads();
52532 result = (wxRelationship)(arg1)->GetRelationship();
52533 wxPyEndAllowThreads(__tstate);
52534 if (PyErr_Occurred()) SWIG_fail;
52535 }
52536 resultobj = SWIG_From_int(static_cast< int >(result));
52537 return resultobj;
52538 fail:
52539 return NULL;
52540 }
52541
52542
52543 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52544 PyObject *resultobj = 0;
52545 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52546 wxRelationship arg2 ;
52547 void *argp1 = 0 ;
52548 int res1 = 0 ;
52549 int val2 ;
52550 int ecode2 = 0 ;
52551 PyObject * obj0 = 0 ;
52552 PyObject * obj1 = 0 ;
52553 char * kwnames[] = {
52554 (char *) "self",(char *) "r", NULL
52555 };
52556
52557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52559 if (!SWIG_IsOK(res1)) {
52560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52561 }
52562 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52563 ecode2 = SWIG_AsVal_int(obj1, &val2);
52564 if (!SWIG_IsOK(ecode2)) {
52565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52566 }
52567 arg2 = static_cast< wxRelationship >(val2);
52568 {
52569 PyThreadState* __tstate = wxPyBeginAllowThreads();
52570 (arg1)->SetRelationship(arg2);
52571 wxPyEndAllowThreads(__tstate);
52572 if (PyErr_Occurred()) SWIG_fail;
52573 }
52574 resultobj = SWIG_Py_Void();
52575 return resultobj;
52576 fail:
52577 return NULL;
52578 }
52579
52580
52581 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52582 PyObject *resultobj = 0;
52583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52584 wxWindow *arg2 = (wxWindow *) 0 ;
52585 bool result;
52586 void *argp1 = 0 ;
52587 int res1 = 0 ;
52588 void *argp2 = 0 ;
52589 int res2 = 0 ;
52590 PyObject * obj0 = 0 ;
52591 PyObject * obj1 = 0 ;
52592 char * kwnames[] = {
52593 (char *) "self",(char *) "otherW", NULL
52594 };
52595
52596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52598 if (!SWIG_IsOK(res1)) {
52599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52600 }
52601 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52603 if (!SWIG_IsOK(res2)) {
52604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52605 }
52606 arg2 = reinterpret_cast< wxWindow * >(argp2);
52607 {
52608 PyThreadState* __tstate = wxPyBeginAllowThreads();
52609 result = (bool)(arg1)->ResetIfWin(arg2);
52610 wxPyEndAllowThreads(__tstate);
52611 if (PyErr_Occurred()) SWIG_fail;
52612 }
52613 {
52614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52615 }
52616 return resultobj;
52617 fail:
52618 return NULL;
52619 }
52620
52621
52622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52623 PyObject *resultobj = 0;
52624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52625 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52626 wxWindow *arg3 = (wxWindow *) 0 ;
52627 bool result;
52628 void *argp1 = 0 ;
52629 int res1 = 0 ;
52630 void *argp2 = 0 ;
52631 int res2 = 0 ;
52632 void *argp3 = 0 ;
52633 int res3 = 0 ;
52634 PyObject * obj0 = 0 ;
52635 PyObject * obj1 = 0 ;
52636 PyObject * obj2 = 0 ;
52637 char * kwnames[] = {
52638 (char *) "self",(char *) "constraints",(char *) "win", NULL
52639 };
52640
52641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52643 if (!SWIG_IsOK(res1)) {
52644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52645 }
52646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52648 if (!SWIG_IsOK(res2)) {
52649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52650 }
52651 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52652 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52653 if (!SWIG_IsOK(res3)) {
52654 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52655 }
52656 arg3 = reinterpret_cast< wxWindow * >(argp3);
52657 {
52658 PyThreadState* __tstate = wxPyBeginAllowThreads();
52659 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52660 wxPyEndAllowThreads(__tstate);
52661 if (PyErr_Occurred()) SWIG_fail;
52662 }
52663 {
52664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52665 }
52666 return resultobj;
52667 fail:
52668 return NULL;
52669 }
52670
52671
52672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52673 PyObject *resultobj = 0;
52674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52675 wxEdge arg2 ;
52676 wxWindow *arg3 = (wxWindow *) 0 ;
52677 wxWindow *arg4 = (wxWindow *) 0 ;
52678 int result;
52679 void *argp1 = 0 ;
52680 int res1 = 0 ;
52681 int val2 ;
52682 int ecode2 = 0 ;
52683 void *argp3 = 0 ;
52684 int res3 = 0 ;
52685 void *argp4 = 0 ;
52686 int res4 = 0 ;
52687 PyObject * obj0 = 0 ;
52688 PyObject * obj1 = 0 ;
52689 PyObject * obj2 = 0 ;
52690 PyObject * obj3 = 0 ;
52691 char * kwnames[] = {
52692 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52693 };
52694
52695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52697 if (!SWIG_IsOK(res1)) {
52698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52699 }
52700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52701 ecode2 = SWIG_AsVal_int(obj1, &val2);
52702 if (!SWIG_IsOK(ecode2)) {
52703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52704 }
52705 arg2 = static_cast< wxEdge >(val2);
52706 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52707 if (!SWIG_IsOK(res3)) {
52708 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52709 }
52710 arg3 = reinterpret_cast< wxWindow * >(argp3);
52711 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52712 if (!SWIG_IsOK(res4)) {
52713 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52714 }
52715 arg4 = reinterpret_cast< wxWindow * >(argp4);
52716 {
52717 PyThreadState* __tstate = wxPyBeginAllowThreads();
52718 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52719 wxPyEndAllowThreads(__tstate);
52720 if (PyErr_Occurred()) SWIG_fail;
52721 }
52722 resultobj = SWIG_From_int(static_cast< int >(result));
52723 return resultobj;
52724 fail:
52725 return NULL;
52726 }
52727
52728
52729 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52730 PyObject *obj;
52731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52732 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52733 return SWIG_Py_Void();
52734 }
52735
52736 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52737 PyObject *resultobj = 0;
52738 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52739 wxIndividualLayoutConstraint *result = 0 ;
52740 void *argp1 = 0 ;
52741 int res1 = 0 ;
52742 PyObject *swig_obj[1] ;
52743
52744 if (!args) SWIG_fail;
52745 swig_obj[0] = args;
52746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52747 if (!SWIG_IsOK(res1)) {
52748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52749 }
52750 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52751 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52753 return resultobj;
52754 fail:
52755 return NULL;
52756 }
52757
52758
52759 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52760 PyObject *resultobj = 0;
52761 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52762 wxIndividualLayoutConstraint *result = 0 ;
52763 void *argp1 = 0 ;
52764 int res1 = 0 ;
52765 PyObject *swig_obj[1] ;
52766
52767 if (!args) SWIG_fail;
52768 swig_obj[0] = args;
52769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52770 if (!SWIG_IsOK(res1)) {
52771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52772 }
52773 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52774 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52776 return resultobj;
52777 fail:
52778 return NULL;
52779 }
52780
52781
52782 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52783 PyObject *resultobj = 0;
52784 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52785 wxIndividualLayoutConstraint *result = 0 ;
52786 void *argp1 = 0 ;
52787 int res1 = 0 ;
52788 PyObject *swig_obj[1] ;
52789
52790 if (!args) SWIG_fail;
52791 swig_obj[0] = args;
52792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52793 if (!SWIG_IsOK(res1)) {
52794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52795 }
52796 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52797 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52799 return resultobj;
52800 fail:
52801 return NULL;
52802 }
52803
52804
52805 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52806 PyObject *resultobj = 0;
52807 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52808 wxIndividualLayoutConstraint *result = 0 ;
52809 void *argp1 = 0 ;
52810 int res1 = 0 ;
52811 PyObject *swig_obj[1] ;
52812
52813 if (!args) SWIG_fail;
52814 swig_obj[0] = args;
52815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52816 if (!SWIG_IsOK(res1)) {
52817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52818 }
52819 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52820 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52822 return resultobj;
52823 fail:
52824 return NULL;
52825 }
52826
52827
52828 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52829 PyObject *resultobj = 0;
52830 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52831 wxIndividualLayoutConstraint *result = 0 ;
52832 void *argp1 = 0 ;
52833 int res1 = 0 ;
52834 PyObject *swig_obj[1] ;
52835
52836 if (!args) SWIG_fail;
52837 swig_obj[0] = args;
52838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52839 if (!SWIG_IsOK(res1)) {
52840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52841 }
52842 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52843 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52845 return resultobj;
52846 fail:
52847 return NULL;
52848 }
52849
52850
52851 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52852 PyObject *resultobj = 0;
52853 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52854 wxIndividualLayoutConstraint *result = 0 ;
52855 void *argp1 = 0 ;
52856 int res1 = 0 ;
52857 PyObject *swig_obj[1] ;
52858
52859 if (!args) SWIG_fail;
52860 swig_obj[0] = args;
52861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52862 if (!SWIG_IsOK(res1)) {
52863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52864 }
52865 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52866 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52868 return resultobj;
52869 fail:
52870 return NULL;
52871 }
52872
52873
52874 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52875 PyObject *resultobj = 0;
52876 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52877 wxIndividualLayoutConstraint *result = 0 ;
52878 void *argp1 = 0 ;
52879 int res1 = 0 ;
52880 PyObject *swig_obj[1] ;
52881
52882 if (!args) SWIG_fail;
52883 swig_obj[0] = args;
52884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52885 if (!SWIG_IsOK(res1)) {
52886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52887 }
52888 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52889 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52891 return resultobj;
52892 fail:
52893 return NULL;
52894 }
52895
52896
52897 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52898 PyObject *resultobj = 0;
52899 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52900 wxIndividualLayoutConstraint *result = 0 ;
52901 void *argp1 = 0 ;
52902 int res1 = 0 ;
52903 PyObject *swig_obj[1] ;
52904
52905 if (!args) SWIG_fail;
52906 swig_obj[0] = args;
52907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52908 if (!SWIG_IsOK(res1)) {
52909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52910 }
52911 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52912 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52914 return resultobj;
52915 fail:
52916 return NULL;
52917 }
52918
52919
52920 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52921 PyObject *resultobj = 0;
52922 wxLayoutConstraints *result = 0 ;
52923
52924 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52925 {
52926 PyThreadState* __tstate = wxPyBeginAllowThreads();
52927 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52928 wxPyEndAllowThreads(__tstate);
52929 if (PyErr_Occurred()) SWIG_fail;
52930 }
52931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52932 return resultobj;
52933 fail:
52934 return NULL;
52935 }
52936
52937
52938 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52939 PyObject *resultobj = 0;
52940 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52941 void *argp1 = 0 ;
52942 int res1 = 0 ;
52943 PyObject *swig_obj[1] ;
52944
52945 if (!args) SWIG_fail;
52946 swig_obj[0] = args;
52947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52948 if (!SWIG_IsOK(res1)) {
52949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52950 }
52951 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52952 {
52953 PyThreadState* __tstate = wxPyBeginAllowThreads();
52954 delete arg1;
52955
52956 wxPyEndAllowThreads(__tstate);
52957 if (PyErr_Occurred()) SWIG_fail;
52958 }
52959 resultobj = SWIG_Py_Void();
52960 return resultobj;
52961 fail:
52962 return NULL;
52963 }
52964
52965
52966 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52967 PyObject *resultobj = 0;
52968 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52969 wxWindow *arg2 = (wxWindow *) 0 ;
52970 int *arg3 = (int *) 0 ;
52971 bool result;
52972 void *argp1 = 0 ;
52973 int res1 = 0 ;
52974 void *argp2 = 0 ;
52975 int res2 = 0 ;
52976 int temp3 ;
52977 int res3 = SWIG_TMPOBJ ;
52978 PyObject * obj0 = 0 ;
52979 PyObject * obj1 = 0 ;
52980 char * kwnames[] = {
52981 (char *) "self",(char *) "win", NULL
52982 };
52983
52984 arg3 = &temp3;
52985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52987 if (!SWIG_IsOK(res1)) {
52988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52989 }
52990 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52992 if (!SWIG_IsOK(res2)) {
52993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52994 }
52995 arg2 = reinterpret_cast< wxWindow * >(argp2);
52996 {
52997 PyThreadState* __tstate = wxPyBeginAllowThreads();
52998 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52999 wxPyEndAllowThreads(__tstate);
53000 if (PyErr_Occurred()) SWIG_fail;
53001 }
53002 {
53003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53004 }
53005 if (SWIG_IsTmpObj(res3)) {
53006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53007 } else {
53008 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53010 }
53011 return resultobj;
53012 fail:
53013 return NULL;
53014 }
53015
53016
53017 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53018 PyObject *resultobj = 0;
53019 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53020 bool result;
53021 void *argp1 = 0 ;
53022 int res1 = 0 ;
53023 PyObject *swig_obj[1] ;
53024
53025 if (!args) SWIG_fail;
53026 swig_obj[0] = args;
53027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53028 if (!SWIG_IsOK(res1)) {
53029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53030 }
53031 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53032 {
53033 PyThreadState* __tstate = wxPyBeginAllowThreads();
53034 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53035 wxPyEndAllowThreads(__tstate);
53036 if (PyErr_Occurred()) SWIG_fail;
53037 }
53038 {
53039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53040 }
53041 return resultobj;
53042 fail:
53043 return NULL;
53044 }
53045
53046
53047 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53048 PyObject *obj;
53049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53050 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53051 return SWIG_Py_Void();
53052 }
53053
53054 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53055 return SWIG_Python_InitShadowInstance(args);
53056 }
53057
53058 static PyMethodDef SwigMethods[] = {
53059 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53060 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53061 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53062 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53063 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53064 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53065 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53066 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53067 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53069 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53080 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53081 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53082 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53084 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53085 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53086 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53087 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53088 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53089 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53090 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53092 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53098 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53099 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53100 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53101 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53102 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53103 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53104 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53106 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53114 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53115 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53116 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53121 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53122 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53124 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53126 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53128 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53130 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53132 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53134 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53135 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53137 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53139 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53140 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53141 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53142 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53162 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53163 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53164 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53165 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53166 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53167 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53168 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53169 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53171 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53172 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53173 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53178 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53179 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53180 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53181 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53188 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53195 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53196 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53197 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53198 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53200 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53201 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53202 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53204 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53205 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53206 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53207 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53212 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53213 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53214 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53215 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53216 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53217 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53220 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53221 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53222 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53224 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53225 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53227 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53228 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53229 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53230 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53231 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53232 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53233 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53234 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53235 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53236 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53237 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53242 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53248 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53249 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53250 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53251 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53253 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53256 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53258 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53261 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53262 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53263 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53266 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53267 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53268 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53272 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53273 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53274 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53278 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53283 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53284 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53285 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53286 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53287 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53288 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53289 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53296 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53297 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53299 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53301 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53307 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53310 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53311 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53312 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53313 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53314 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53315 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53316 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53319 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53320 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53321 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53322 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53323 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53324 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53325 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53326 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53328 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53337 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53349 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53350 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53365 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53366 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53367 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53368 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53371 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53373 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53375 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53377 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53379 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53382 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53383 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53384 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53385 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53387 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53404 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53405 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53411 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53412 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53414 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53415 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53417 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53418 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53420 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53421 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53423 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53424 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53426 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53427 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53429 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53430 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53431 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53432 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53433 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53434 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53435 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53436 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53437 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53438 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53439 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53440 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53441 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53442 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53443 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53444 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53445 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53446 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53448 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53449 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53450 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53451 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53454 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53458 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53462 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53463 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53464 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53465 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53467 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53468 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53470 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53472 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53474 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53476 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53477 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53478 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53480 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53481 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53483 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53484 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53485 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53487 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53488 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53489 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53491 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53493 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53494 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53495 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53497 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53499 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53500 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53502 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53503 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53504 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53506 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53507 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53508 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53509 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53510 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53512 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53513 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53516 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53517 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53519 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53520 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53523 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53524 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53526 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53532 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53533 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53534 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53535 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53536 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53537 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53538 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53539 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53540 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53541 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53542 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53543 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53544 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53545 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53546 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53547 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53548 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53549 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53550 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53551 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53552 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53553 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53554 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53555 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53557 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53558 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53559 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53560 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53561 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53562 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53563 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53564 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53565 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53566 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53567 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53568 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53569 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53570 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53571 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53572 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53573 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53574 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53575 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53576 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53577 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53578 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53579 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53580 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53581 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53582 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53583 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53584 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53585 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53586 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53587 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53588 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53590 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53591 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53593 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53594 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53595 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53596 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53598 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53599 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53600 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53601 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53602 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53603 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53604 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53605 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53606 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53608 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53609 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53610 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53611 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53612 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53613 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53614 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53615 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53616 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53617 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53618 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53619 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53620 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53621 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53622 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53623 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53624 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53625 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53626 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53627 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53628 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53629 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53630 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53631 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53632 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53633 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53634 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53635 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53637 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53638 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53641 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53642 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53643 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53644 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53645 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53646 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53648 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53649 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53652 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53653 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53655 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53656 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53658 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53659 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53661 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53662 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53665 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53667 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53668 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53670 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53671 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53672 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53674 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53675 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53676 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53678 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53679 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53681 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53682 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53683 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53684 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53685 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53688 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53690 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53692 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53693 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53694 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53697 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53698 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53699 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53701 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53702 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53703 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53705 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53706 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53707 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53708 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53709 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53710 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53712 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53713 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53714 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53715 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53716 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53717 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53718 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53719 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53725 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53727 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53729 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53730 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53731 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53732 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53733 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53734 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53736 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53737 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53738 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53740 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53742 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53743 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53744 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53747 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53748 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53749 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53752 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53753 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53754 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53755 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53756 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53758 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53760 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53763 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53765 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53766 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53768 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53769 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53770 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53772 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53773 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53774 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53776 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53778 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53779 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53780 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53782 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53784 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53786 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53787 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53789 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53790 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53792 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53794 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53795 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53796 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53798 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53800 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53801 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53802 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53804 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53806 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53807 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53808 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53809 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53811 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53813 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53815 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53817 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53818 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53820 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53821 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53822 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53823 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53824 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53825 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53826 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53827 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53829 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53831 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53833 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53835 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53837 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53839 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53840 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53841 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53842 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53843 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53844 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53850 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53851 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53852 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53853 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53854 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53855 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53856 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53857 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53859 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53861 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53862 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53864 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53865 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53866 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53867 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53869 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53870 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53871 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53872 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53874 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53875 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53877 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53878 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53879 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53881 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53883 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53884 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53885 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53886 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53887 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53889 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53890 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53891 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53892 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53894 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53895 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53896 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53897 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53898 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53899 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53900 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53901 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53902 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53903 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53905 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53908 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53909 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53910 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53912 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53914 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53916 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53918 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53919 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53929 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53930 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53934 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53935 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53936 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53937 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53938 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53939 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53940 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53941 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53942 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53943 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53944 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53945 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53946 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53947 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53948 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53950 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53951 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53954 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53955 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53960 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53961 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53964 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53965 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53966 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53967 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53970 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53971 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53972 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53974 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53976 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53977 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53978 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53980 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53982 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53984 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53987 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53988 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53989 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53990 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53991 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53992 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53996 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53997 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53998 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53999 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54006 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54012 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54013 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54014 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54015 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54016 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54018 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54028 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54029 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54030 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54031 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54034 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54035 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54036 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54037 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54039 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54040 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54044 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54050 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54051 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54052 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54053 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54055 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54056 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54058 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54061 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54063 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54064 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54065 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54074 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54078 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54079 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54081 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54091 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54092 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54093 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54094 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54098 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54101 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54103 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54106 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54108 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54109 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54112 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54114 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54115 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54116 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54117 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54119 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54120 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54125 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54126 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54127 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54129 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54130 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54131 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54133 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54135 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54136 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54137 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54139 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54140 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54143 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54151 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54158 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54166 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54169 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54170 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54183 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54185 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54187 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54188 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54190 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54192 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54193 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54195 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54196 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54197 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54201 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54220 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54221 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54223 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54224 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54226 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54227 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54228 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54230 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54231 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54234 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54235 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54237 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54238 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54240 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54243 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54244 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54246 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54248 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54250 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54251 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54253 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54254 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54257 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54259 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54261 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54263 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54266 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54268 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54269 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54270 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54272 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54273 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54274 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54276 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54278 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54279 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54281 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54283 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54284 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54288 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54292 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54293 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54295 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54299 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54301 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54303 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54304 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54305 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54306 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54310 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54311 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54312 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54313 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54315 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54316 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54321 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54322 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54323 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54324 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54325 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54327 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54329 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54331 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54332 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54334 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54336 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54339 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54340 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54341 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54343 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54344 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54345 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54359 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54360 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54361 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54362 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54363 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54364 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54370 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54371 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54375 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54376 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54378 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54379 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54381 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54383 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54384 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54386 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54387 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54388 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54394 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54395 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54396 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54397 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54398 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54399 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54406 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54408 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54409 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54410 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54411 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54412 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54413 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54415 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54419 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54420 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54421 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54422 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54423 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54424 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54425 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54427 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54428 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54429 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54435 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54436 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54437 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54439 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54440 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54441 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54447 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54448 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54449 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54450 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54451 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54455 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54456 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54461 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54462 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54464 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54465 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54470 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54472 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54473 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54474 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54475 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54476 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54481 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54482 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54491 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54492 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54493 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54494 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54497 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54499 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54500 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54501 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54502 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54504 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54509 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54510 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54511 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54512 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54513 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54514 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54515 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54516 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54517 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54518 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54519 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54521 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54522 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54523 { NULL, NULL, 0, NULL }
54524 };
54525
54526
54527 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54528
54529 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54530 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54531 }
54532 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54533 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54534 }
54535 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54536 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54537 }
54538 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54539 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54540 }
54541 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54542 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54543 }
54544 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54545 return (void *)((wxSizer *) ((wxGridSizer *) x));
54546 }
54547 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54548 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54549 }
54550 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54551 return (void *)((wxSizer *) ((wxPySizer *) x));
54552 }
54553 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54554 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54555 }
54556 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54557 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54558 }
54559 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54560 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54561 }
54562 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54563 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54564 }
54565 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54566 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54567 }
54568 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54569 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54570 }
54571 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54572 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54573 }
54574 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54575 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54576 }
54577 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54578 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54579 }
54580 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54581 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54582 }
54583 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54584 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54585 }
54586 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54587 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54588 }
54589 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54590 return (void *)((wxEvent *) ((wxPyEvent *) x));
54591 }
54592 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54593 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54594 }
54595 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54596 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54597 }
54598 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54599 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54600 }
54601 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54602 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54603 }
54604 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54605 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54606 }
54607 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54608 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54609 }
54610 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54611 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54612 }
54613 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54614 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54615 }
54616 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54617 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54618 }
54619 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54620 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54621 }
54622 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54623 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54624 }
54625 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54626 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54627 }
54628 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54629 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54630 }
54631 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54632 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54633 }
54634 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54635 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54636 }
54637 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54638 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54639 }
54640 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54641 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54642 }
54643 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54644 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54645 }
54646 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54647 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54648 }
54649 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54650 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54651 }
54652 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54653 return (void *)((wxEvent *) ((wxShowEvent *) x));
54654 }
54655 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54656 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54657 }
54658 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54659 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54660 }
54661 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54663 }
54664 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54665 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54666 }
54667 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54668 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54669 }
54670 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54671 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54672 }
54673 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54674 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54675 }
54676 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54677 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54678 }
54679 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54680 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54681 }
54682 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54683 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54684 }
54685 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54686 return (void *)((wxControl *) ((wxControlWithItems *) x));
54687 }
54688 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54689 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54690 }
54691 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54692 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54693 }
54694 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54695 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54696 }
54697 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54698 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54699 }
54700 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54701 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54702 }
54703 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54704 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54705 }
54706 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54707 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54708 }
54709 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54710 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54711 }
54712 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54713 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54714 }
54715 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54716 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54717 }
54718 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54719 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54720 }
54721 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54722 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54723 }
54724 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54725 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54726 }
54727 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54728 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54729 }
54730 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54731 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54732 }
54733 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54734 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54735 }
54736 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54737 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54738 }
54739 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54740 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54741 }
54742 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54743 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54744 }
54745 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54746 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54747 }
54748 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54749 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54750 }
54751 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54752 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54753 }
54754 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54755 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54756 }
54757 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54758 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54759 }
54760 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54761 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54762 }
54763 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54764 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54765 }
54766 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54767 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54768 }
54769 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54770 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54771 }
54772 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54773 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54774 }
54775 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54776 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54777 }
54778 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54779 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54780 }
54781 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54782 return (void *)((wxObject *) ((wxSizerItem *) x));
54783 }
54784 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54785 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54786 }
54787 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54788 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54789 }
54790 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54791 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54792 }
54793 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54794 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54795 }
54796 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54797 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54798 }
54799 static void *_p_wxSizerTo_p_wxObject(void *x) {
54800 return (void *)((wxObject *) ((wxSizer *) x));
54801 }
54802 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54803 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54804 }
54805 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54806 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54807 }
54808 static void *_p_wxEventTo_p_wxObject(void *x) {
54809 return (void *)((wxObject *) ((wxEvent *) x));
54810 }
54811 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54812 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54813 }
54814 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54815 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54816 }
54817 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54818 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54819 }
54820 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54821 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54822 }
54823 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54824 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54825 }
54826 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54827 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54828 }
54829 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54830 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54831 }
54832 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54833 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54834 }
54835 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54836 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54837 }
54838 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54839 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54840 }
54841 static void *_p_wxControlTo_p_wxObject(void *x) {
54842 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54843 }
54844 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54845 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54846 }
54847 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54848 return (void *)((wxObject *) ((wxFSFile *) x));
54849 }
54850 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54851 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54852 }
54853 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54854 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54855 }
54856 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54857 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54858 }
54859 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54860 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54861 }
54862 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54863 return (void *)((wxObject *) ((wxMenuItem *) x));
54864 }
54865 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54866 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54867 }
54868 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54869 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54870 }
54871 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54872 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54873 }
54874 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54875 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54876 }
54877 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54878 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54879 }
54880 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54881 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54882 }
54883 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54884 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54885 }
54886 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54887 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54888 }
54889 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54890 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54891 }
54892 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54893 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54894 }
54895 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54896 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54897 }
54898 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54899 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54900 }
54901 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54902 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54903 }
54904 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54905 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54906 }
54907 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54908 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54909 }
54910 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54911 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54912 }
54913 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54914 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54915 }
54916 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54917 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54918 }
54919 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54920 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54921 }
54922 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54923 return (void *)((wxObject *) ((wxImageHandler *) x));
54924 }
54925 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54926 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54927 }
54928 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54929 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54930 }
54931 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54932 return (void *)((wxObject *) ((wxEvtHandler *) x));
54933 }
54934 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54935 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54936 }
54937 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54938 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54939 }
54940 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54941 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54942 }
54943 static void *_p_wxImageTo_p_wxObject(void *x) {
54944 return (void *)((wxObject *) ((wxImage *) x));
54945 }
54946 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54947 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54948 }
54949 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54950 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54951 }
54952 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54953 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54954 }
54955 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54956 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54957 }
54958 static void *_p_wxWindowTo_p_wxObject(void *x) {
54959 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54960 }
54961 static void *_p_wxMenuTo_p_wxObject(void *x) {
54962 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54963 }
54964 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54965 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54966 }
54967 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54968 return (void *)((wxObject *) ((wxFileSystem *) x));
54969 }
54970 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54971 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54972 }
54973 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54974 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54975 }
54976 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54977 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54978 }
54979 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54980 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54981 }
54982 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54983 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54984 }
54985 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54986 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54987 }
54988 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54989 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54990 }
54991 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54992 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54993 }
54994 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54995 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54996 }
54997 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54998 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54999 }
55000 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55001 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55002 }
55003 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55004 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55005 }
55006 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55007 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55008 }
55009 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55010 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55011 }
55012 static void *_p_wxControlTo_p_wxWindow(void *x) {
55013 return (void *)((wxWindow *) ((wxControl *) x));
55014 }
55015 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55016 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55017 }
55018 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55019 return (void *)((wxWindow *) ((wxMenuBar *) x));
55020 }
55021 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55022 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55023 }
55024 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55025 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55026 }
55027 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55028 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55029 }
55030 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55031 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55032 }
55033 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55034 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55035 }
55036 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55037 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55038 }
55039 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55040 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55041 }
55042 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55043 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55044 }
55045 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55046 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55047 }
55048 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55049 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55050 }
55051 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55052 return (void *)((wxValidator *) ((wxPyValidator *) x));
55053 }
55054 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55055 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55056 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};
55057 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55178 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55179 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55180 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55181 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55182 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55183 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55184 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55185 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55186
55187 static swig_type_info *swig_type_initial[] = {
55188 &_swigt__p_buffer,
55189 &_swigt__p_char,
55190 &_swigt__p_form_ops_t,
55191 &_swigt__p_int,
55192 &_swigt__p_long,
55193 &_swigt__p_unsigned_char,
55194 &_swigt__p_unsigned_int,
55195 &_swigt__p_unsigned_long,
55196 &_swigt__p_wxANIHandler,
55197 &_swigt__p_wxAcceleratorEntry,
55198 &_swigt__p_wxAcceleratorTable,
55199 &_swigt__p_wxActivateEvent,
55200 &_swigt__p_wxAppTraits,
55201 &_swigt__p_wxArrayString,
55202 &_swigt__p_wxBMPHandler,
55203 &_swigt__p_wxBitmap,
55204 &_swigt__p_wxBoxSizer,
55205 &_swigt__p_wxButton,
55206 &_swigt__p_wxCURHandler,
55207 &_swigt__p_wxCaret,
55208 &_swigt__p_wxChildFocusEvent,
55209 &_swigt__p_wxClipboardTextEvent,
55210 &_swigt__p_wxCloseEvent,
55211 &_swigt__p_wxColour,
55212 &_swigt__p_wxCommandEvent,
55213 &_swigt__p_wxContextMenuEvent,
55214 &_swigt__p_wxControl,
55215 &_swigt__p_wxControlWithItems,
55216 &_swigt__p_wxCursor,
55217 &_swigt__p_wxDC,
55218 &_swigt__p_wxDateEvent,
55219 &_swigt__p_wxDateTime,
55220 &_swigt__p_wxDisplayChangedEvent,
55221 &_swigt__p_wxDropFilesEvent,
55222 &_swigt__p_wxDuplexMode,
55223 &_swigt__p_wxEraseEvent,
55224 &_swigt__p_wxEvent,
55225 &_swigt__p_wxEventLoop,
55226 &_swigt__p_wxEventLoopActivator,
55227 &_swigt__p_wxEvtHandler,
55228 &_swigt__p_wxFSFile,
55229 &_swigt__p_wxFileSystem,
55230 &_swigt__p_wxFileSystemHandler,
55231 &_swigt__p_wxFlexGridSizer,
55232 &_swigt__p_wxFocusEvent,
55233 &_swigt__p_wxFont,
55234 &_swigt__p_wxFrame,
55235 &_swigt__p_wxGBPosition,
55236 &_swigt__p_wxGBSizerItem,
55237 &_swigt__p_wxGBSpan,
55238 &_swigt__p_wxGIFHandler,
55239 &_swigt__p_wxGridBagSizer,
55240 &_swigt__p_wxGridSizer,
55241 &_swigt__p_wxHelpEvent__Origin,
55242 &_swigt__p_wxICOHandler,
55243 &_swigt__p_wxIconizeEvent,
55244 &_swigt__p_wxIdleEvent,
55245 &_swigt__p_wxImage,
55246 &_swigt__p_wxImageHandler,
55247 &_swigt__p_wxImageHistogram,
55248 &_swigt__p_wxImage_HSVValue,
55249 &_swigt__p_wxImage_RGBValue,
55250 &_swigt__p_wxIndividualLayoutConstraint,
55251 &_swigt__p_wxInitDialogEvent,
55252 &_swigt__p_wxInputStream,
55253 &_swigt__p_wxInternetFSHandler,
55254 &_swigt__p_wxItemContainer,
55255 &_swigt__p_wxJPEGHandler,
55256 &_swigt__p_wxKeyEvent,
55257 &_swigt__p_wxLayoutConstraints,
55258 &_swigt__p_wxMaximizeEvent,
55259 &_swigt__p_wxMemoryFSHandler,
55260 &_swigt__p_wxMenu,
55261 &_swigt__p_wxMenuBar,
55262 &_swigt__p_wxMenuBarBase,
55263 &_swigt__p_wxMenuEvent,
55264 &_swigt__p_wxMenuItem,
55265 &_swigt__p_wxMouseCaptureChangedEvent,
55266 &_swigt__p_wxMouseCaptureLostEvent,
55267 &_swigt__p_wxMouseEvent,
55268 &_swigt__p_wxMoveEvent,
55269 &_swigt__p_wxNavigationKeyEvent,
55270 &_swigt__p_wxNcPaintEvent,
55271 &_swigt__p_wxNotifyEvent,
55272 &_swigt__p_wxObject,
55273 &_swigt__p_wxOutputStream,
55274 &_swigt__p_wxPCXHandler,
55275 &_swigt__p_wxPNGHandler,
55276 &_swigt__p_wxPNMHandler,
55277 &_swigt__p_wxPaintEvent,
55278 &_swigt__p_wxPaletteChangedEvent,
55279 &_swigt__p_wxPaperSize,
55280 &_swigt__p_wxPoint,
55281 &_swigt__p_wxPoint2D,
55282 &_swigt__p_wxPropagateOnce,
55283 &_swigt__p_wxPropagationDisabler,
55284 &_swigt__p_wxPyApp,
55285 &_swigt__p_wxPyCommandEvent,
55286 &_swigt__p_wxPyDropTarget,
55287 &_swigt__p_wxPyEvent,
55288 &_swigt__p_wxPyFileSystemHandler,
55289 &_swigt__p_wxPyImageHandler,
55290 &_swigt__p_wxPyInputStream,
55291 &_swigt__p_wxPySizer,
55292 &_swigt__p_wxPyValidator,
55293 &_swigt__p_wxQuantize,
55294 &_swigt__p_wxQueryNewPaletteEvent,
55295 &_swigt__p_wxRealPoint,
55296 &_swigt__p_wxRect,
55297 &_swigt__p_wxRegion,
55298 &_swigt__p_wxScrollEvent,
55299 &_swigt__p_wxScrollWinEvent,
55300 &_swigt__p_wxSetCursorEvent,
55301 &_swigt__p_wxShowEvent,
55302 &_swigt__p_wxSize,
55303 &_swigt__p_wxSizeEvent,
55304 &_swigt__p_wxSizer,
55305 &_swigt__p_wxSizerItem,
55306 &_swigt__p_wxStaticBox,
55307 &_swigt__p_wxStaticBoxSizer,
55308 &_swigt__p_wxStdDialogButtonSizer,
55309 &_swigt__p_wxSysColourChangedEvent,
55310 &_swigt__p_wxTIFFHandler,
55311 &_swigt__p_wxToolTip,
55312 &_swigt__p_wxUpdateUIEvent,
55313 &_swigt__p_wxValidator,
55314 &_swigt__p_wxVisualAttributes,
55315 &_swigt__p_wxWindow,
55316 &_swigt__p_wxWindowCreateEvent,
55317 &_swigt__p_wxWindowDestroyEvent,
55318 &_swigt__p_wxXPMHandler,
55319 &_swigt__p_wxZipFSHandler,
55320 };
55321
55322 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55323 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55327 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55328 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55329 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55330 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55331 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55332 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55336 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}};
55337 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55338 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}};
55339 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55340 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}};
55341 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55346 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
55347 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55348 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}};
55349 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55355 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55356 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55357 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55358 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55361 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}};
55362 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55364 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}};
55365 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}};
55366 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55367 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55374 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}};
55375 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55376 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}};
55377 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55380 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}};
55381 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55388 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}};
55389 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55430 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55431 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55438 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}};
55439 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}};
55440 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55441 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55446 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55447 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}};
55448 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55449 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}};
55450 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55451 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55452 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55453 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55454
55455 static swig_cast_info *swig_cast_initial[] = {
55456 _swigc__p_buffer,
55457 _swigc__p_char,
55458 _swigc__p_form_ops_t,
55459 _swigc__p_int,
55460 _swigc__p_long,
55461 _swigc__p_unsigned_char,
55462 _swigc__p_unsigned_int,
55463 _swigc__p_unsigned_long,
55464 _swigc__p_wxANIHandler,
55465 _swigc__p_wxAcceleratorEntry,
55466 _swigc__p_wxAcceleratorTable,
55467 _swigc__p_wxActivateEvent,
55468 _swigc__p_wxAppTraits,
55469 _swigc__p_wxArrayString,
55470 _swigc__p_wxBMPHandler,
55471 _swigc__p_wxBitmap,
55472 _swigc__p_wxBoxSizer,
55473 _swigc__p_wxButton,
55474 _swigc__p_wxCURHandler,
55475 _swigc__p_wxCaret,
55476 _swigc__p_wxChildFocusEvent,
55477 _swigc__p_wxClipboardTextEvent,
55478 _swigc__p_wxCloseEvent,
55479 _swigc__p_wxColour,
55480 _swigc__p_wxCommandEvent,
55481 _swigc__p_wxContextMenuEvent,
55482 _swigc__p_wxControl,
55483 _swigc__p_wxControlWithItems,
55484 _swigc__p_wxCursor,
55485 _swigc__p_wxDC,
55486 _swigc__p_wxDateEvent,
55487 _swigc__p_wxDateTime,
55488 _swigc__p_wxDisplayChangedEvent,
55489 _swigc__p_wxDropFilesEvent,
55490 _swigc__p_wxDuplexMode,
55491 _swigc__p_wxEraseEvent,
55492 _swigc__p_wxEvent,
55493 _swigc__p_wxEventLoop,
55494 _swigc__p_wxEventLoopActivator,
55495 _swigc__p_wxEvtHandler,
55496 _swigc__p_wxFSFile,
55497 _swigc__p_wxFileSystem,
55498 _swigc__p_wxFileSystemHandler,
55499 _swigc__p_wxFlexGridSizer,
55500 _swigc__p_wxFocusEvent,
55501 _swigc__p_wxFont,
55502 _swigc__p_wxFrame,
55503 _swigc__p_wxGBPosition,
55504 _swigc__p_wxGBSizerItem,
55505 _swigc__p_wxGBSpan,
55506 _swigc__p_wxGIFHandler,
55507 _swigc__p_wxGridBagSizer,
55508 _swigc__p_wxGridSizer,
55509 _swigc__p_wxHelpEvent__Origin,
55510 _swigc__p_wxICOHandler,
55511 _swigc__p_wxIconizeEvent,
55512 _swigc__p_wxIdleEvent,
55513 _swigc__p_wxImage,
55514 _swigc__p_wxImageHandler,
55515 _swigc__p_wxImageHistogram,
55516 _swigc__p_wxImage_HSVValue,
55517 _swigc__p_wxImage_RGBValue,
55518 _swigc__p_wxIndividualLayoutConstraint,
55519 _swigc__p_wxInitDialogEvent,
55520 _swigc__p_wxInputStream,
55521 _swigc__p_wxInternetFSHandler,
55522 _swigc__p_wxItemContainer,
55523 _swigc__p_wxJPEGHandler,
55524 _swigc__p_wxKeyEvent,
55525 _swigc__p_wxLayoutConstraints,
55526 _swigc__p_wxMaximizeEvent,
55527 _swigc__p_wxMemoryFSHandler,
55528 _swigc__p_wxMenu,
55529 _swigc__p_wxMenuBar,
55530 _swigc__p_wxMenuBarBase,
55531 _swigc__p_wxMenuEvent,
55532 _swigc__p_wxMenuItem,
55533 _swigc__p_wxMouseCaptureChangedEvent,
55534 _swigc__p_wxMouseCaptureLostEvent,
55535 _swigc__p_wxMouseEvent,
55536 _swigc__p_wxMoveEvent,
55537 _swigc__p_wxNavigationKeyEvent,
55538 _swigc__p_wxNcPaintEvent,
55539 _swigc__p_wxNotifyEvent,
55540 _swigc__p_wxObject,
55541 _swigc__p_wxOutputStream,
55542 _swigc__p_wxPCXHandler,
55543 _swigc__p_wxPNGHandler,
55544 _swigc__p_wxPNMHandler,
55545 _swigc__p_wxPaintEvent,
55546 _swigc__p_wxPaletteChangedEvent,
55547 _swigc__p_wxPaperSize,
55548 _swigc__p_wxPoint,
55549 _swigc__p_wxPoint2D,
55550 _swigc__p_wxPropagateOnce,
55551 _swigc__p_wxPropagationDisabler,
55552 _swigc__p_wxPyApp,
55553 _swigc__p_wxPyCommandEvent,
55554 _swigc__p_wxPyDropTarget,
55555 _swigc__p_wxPyEvent,
55556 _swigc__p_wxPyFileSystemHandler,
55557 _swigc__p_wxPyImageHandler,
55558 _swigc__p_wxPyInputStream,
55559 _swigc__p_wxPySizer,
55560 _swigc__p_wxPyValidator,
55561 _swigc__p_wxQuantize,
55562 _swigc__p_wxQueryNewPaletteEvent,
55563 _swigc__p_wxRealPoint,
55564 _swigc__p_wxRect,
55565 _swigc__p_wxRegion,
55566 _swigc__p_wxScrollEvent,
55567 _swigc__p_wxScrollWinEvent,
55568 _swigc__p_wxSetCursorEvent,
55569 _swigc__p_wxShowEvent,
55570 _swigc__p_wxSize,
55571 _swigc__p_wxSizeEvent,
55572 _swigc__p_wxSizer,
55573 _swigc__p_wxSizerItem,
55574 _swigc__p_wxStaticBox,
55575 _swigc__p_wxStaticBoxSizer,
55576 _swigc__p_wxStdDialogButtonSizer,
55577 _swigc__p_wxSysColourChangedEvent,
55578 _swigc__p_wxTIFFHandler,
55579 _swigc__p_wxToolTip,
55580 _swigc__p_wxUpdateUIEvent,
55581 _swigc__p_wxValidator,
55582 _swigc__p_wxVisualAttributes,
55583 _swigc__p_wxWindow,
55584 _swigc__p_wxWindowCreateEvent,
55585 _swigc__p_wxWindowDestroyEvent,
55586 _swigc__p_wxXPMHandler,
55587 _swigc__p_wxZipFSHandler,
55588 };
55589
55590
55591 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55592
55593 static swig_const_info swig_const_table[] = {
55594 {0, 0, 0, 0.0, 0, 0}};
55595
55596 #ifdef __cplusplus
55597 }
55598 #endif
55599 /* -----------------------------------------------------------------------------
55600 * Type initialization:
55601 * This problem is tough by the requirement that no dynamic
55602 * memory is used. Also, since swig_type_info structures store pointers to
55603 * swig_cast_info structures and swig_cast_info structures store pointers back
55604 * to swig_type_info structures, we need some lookup code at initialization.
55605 * The idea is that swig generates all the structures that are needed.
55606 * The runtime then collects these partially filled structures.
55607 * The SWIG_InitializeModule function takes these initial arrays out of
55608 * swig_module, and does all the lookup, filling in the swig_module.types
55609 * array with the correct data and linking the correct swig_cast_info
55610 * structures together.
55611 *
55612 * The generated swig_type_info structures are assigned staticly to an initial
55613 * array. We just loop though that array, and handle each type individually.
55614 * First we lookup if this type has been already loaded, and if so, use the
55615 * loaded structure instead of the generated one. Then we have to fill in the
55616 * cast linked list. The cast data is initially stored in something like a
55617 * two-dimensional array. Each row corresponds to a type (there are the same
55618 * number of rows as there are in the swig_type_initial array). Each entry in
55619 * a column is one of the swig_cast_info structures for that type.
55620 * The cast_initial array is actually an array of arrays, because each row has
55621 * a variable number of columns. So to actually build the cast linked list,
55622 * we find the array of casts associated with the type, and loop through it
55623 * adding the casts to the list. The one last trick we need to do is making
55624 * sure the type pointer in the swig_cast_info struct is correct.
55625 *
55626 * First off, we lookup the cast->type name to see if it is already loaded.
55627 * There are three cases to handle:
55628 * 1) If the cast->type has already been loaded AND the type we are adding
55629 * casting info to has not been loaded (it is in this module), THEN we
55630 * replace the cast->type pointer with the type pointer that has already
55631 * been loaded.
55632 * 2) If BOTH types (the one we are adding casting info to, and the
55633 * cast->type) are loaded, THEN the cast info has already been loaded by
55634 * the previous module so we just ignore it.
55635 * 3) Finally, if cast->type has not already been loaded, then we add that
55636 * swig_cast_info to the linked list (because the cast->type) pointer will
55637 * be correct.
55638 * ----------------------------------------------------------------------------- */
55639
55640 #ifdef __cplusplus
55641 extern "C" {
55642 #if 0
55643 } /* c-mode */
55644 #endif
55645 #endif
55646
55647 #if 0
55648 #define SWIGRUNTIME_DEBUG
55649 #endif
55650
55651 SWIGRUNTIME void
55652 SWIG_InitializeModule(void *clientdata) {
55653 size_t i;
55654 swig_module_info *module_head;
55655 static int init_run = 0;
55656
55657 clientdata = clientdata;
55658
55659 if (init_run) return;
55660 init_run = 1;
55661
55662 /* Initialize the swig_module */
55663 swig_module.type_initial = swig_type_initial;
55664 swig_module.cast_initial = swig_cast_initial;
55665
55666 /* Try and load any already created modules */
55667 module_head = SWIG_GetModule(clientdata);
55668 if (module_head) {
55669 swig_module.next = module_head->next;
55670 module_head->next = &swig_module;
55671 } else {
55672 /* This is the first module loaded */
55673 swig_module.next = &swig_module;
55674 SWIG_SetModule(clientdata, &swig_module);
55675 }
55676
55677 /* Now work on filling in swig_module.types */
55678 #ifdef SWIGRUNTIME_DEBUG
55679 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55680 #endif
55681 for (i = 0; i < swig_module.size; ++i) {
55682 swig_type_info *type = 0;
55683 swig_type_info *ret;
55684 swig_cast_info *cast;
55685
55686 #ifdef SWIGRUNTIME_DEBUG
55687 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55688 #endif
55689
55690 /* if there is another module already loaded */
55691 if (swig_module.next != &swig_module) {
55692 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55693 }
55694 if (type) {
55695 /* Overwrite clientdata field */
55696 #ifdef SWIGRUNTIME_DEBUG
55697 printf("SWIG_InitializeModule: found type %s\n", type->name);
55698 #endif
55699 if (swig_module.type_initial[i]->clientdata) {
55700 type->clientdata = swig_module.type_initial[i]->clientdata;
55701 #ifdef SWIGRUNTIME_DEBUG
55702 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55703 #endif
55704 }
55705 } else {
55706 type = swig_module.type_initial[i];
55707 }
55708
55709 /* Insert casting types */
55710 cast = swig_module.cast_initial[i];
55711 while (cast->type) {
55712 /* Don't need to add information already in the list */
55713 ret = 0;
55714 #ifdef SWIGRUNTIME_DEBUG
55715 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55716 #endif
55717 if (swig_module.next != &swig_module) {
55718 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55719 #ifdef SWIGRUNTIME_DEBUG
55720 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55721 #endif
55722 }
55723 if (ret) {
55724 if (type == swig_module.type_initial[i]) {
55725 #ifdef SWIGRUNTIME_DEBUG
55726 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55727 #endif
55728 cast->type = ret;
55729 ret = 0;
55730 } else {
55731 /* Check for casting already in the list */
55732 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55733 #ifdef SWIGRUNTIME_DEBUG
55734 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55735 #endif
55736 if (!ocast) ret = 0;
55737 }
55738 }
55739
55740 if (!ret) {
55741 #ifdef SWIGRUNTIME_DEBUG
55742 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55743 #endif
55744 if (type->cast) {
55745 type->cast->prev = cast;
55746 cast->next = type->cast;
55747 }
55748 type->cast = cast;
55749 }
55750 cast++;
55751 }
55752 /* Set entry in modules->types array equal to the type */
55753 swig_module.types[i] = type;
55754 }
55755 swig_module.types[i] = 0;
55756
55757 #ifdef SWIGRUNTIME_DEBUG
55758 printf("**** SWIG_InitializeModule: Cast List ******\n");
55759 for (i = 0; i < swig_module.size; ++i) {
55760 int j = 0;
55761 swig_cast_info *cast = swig_module.cast_initial[i];
55762 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55763 while (cast->type) {
55764 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55765 cast++;
55766 ++j;
55767 }
55768 printf("---- Total casts: %d\n",j);
55769 }
55770 printf("**** SWIG_InitializeModule: Cast List ******\n");
55771 #endif
55772 }
55773
55774 /* This function will propagate the clientdata field of type to
55775 * any new swig_type_info structures that have been added into the list
55776 * of equivalent types. It is like calling
55777 * SWIG_TypeClientData(type, clientdata) a second time.
55778 */
55779 SWIGRUNTIME void
55780 SWIG_PropagateClientData(void) {
55781 size_t i;
55782 swig_cast_info *equiv;
55783 static int init_run = 0;
55784
55785 if (init_run) return;
55786 init_run = 1;
55787
55788 for (i = 0; i < swig_module.size; i++) {
55789 if (swig_module.types[i]->clientdata) {
55790 equiv = swig_module.types[i]->cast;
55791 while (equiv) {
55792 if (!equiv->converter) {
55793 if (equiv->type && !equiv->type->clientdata)
55794 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55795 }
55796 equiv = equiv->next;
55797 }
55798 }
55799 }
55800 }
55801
55802 #ifdef __cplusplus
55803 #if 0
55804 {
55805 /* c-mode */
55806 #endif
55807 }
55808 #endif
55809
55810
55811
55812 #ifdef __cplusplus
55813 extern "C" {
55814 #endif
55815
55816 /* Python-specific SWIG API */
55817 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55818 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55819 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55820
55821 /* -----------------------------------------------------------------------------
55822 * global variable support code.
55823 * ----------------------------------------------------------------------------- */
55824
55825 typedef struct swig_globalvar {
55826 char *name; /* Name of global variable */
55827 PyObject *(*get_attr)(void); /* Return the current value */
55828 int (*set_attr)(PyObject *); /* Set the value */
55829 struct swig_globalvar *next;
55830 } swig_globalvar;
55831
55832 typedef struct swig_varlinkobject {
55833 PyObject_HEAD
55834 swig_globalvar *vars;
55835 } swig_varlinkobject;
55836
55837 SWIGINTERN PyObject *
55838 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55839 return PyString_FromString("<Swig global variables>");
55840 }
55841
55842 SWIGINTERN PyObject *
55843 swig_varlink_str(swig_varlinkobject *v) {
55844 PyObject *str = PyString_FromString("(");
55845 swig_globalvar *var;
55846 for (var = v->vars; var; var=var->next) {
55847 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55848 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55849 }
55850 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55851 return str;
55852 }
55853
55854 SWIGINTERN int
55855 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55856 PyObject *str = swig_varlink_str(v);
55857 fprintf(fp,"Swig global variables ");
55858 fprintf(fp,"%s\n", PyString_AsString(str));
55859 Py_DECREF(str);
55860 return 0;
55861 }
55862
55863 SWIGINTERN void
55864 swig_varlink_dealloc(swig_varlinkobject *v) {
55865 swig_globalvar *var = v->vars;
55866 while (var) {
55867 swig_globalvar *n = var->next;
55868 free(var->name);
55869 free(var);
55870 var = n;
55871 }
55872 }
55873
55874 SWIGINTERN PyObject *
55875 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55876 PyObject *res = NULL;
55877 swig_globalvar *var = v->vars;
55878 while (var) {
55879 if (strcmp(var->name,n) == 0) {
55880 res = (*var->get_attr)();
55881 break;
55882 }
55883 var = var->next;
55884 }
55885 if (res == NULL && !PyErr_Occurred()) {
55886 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55887 }
55888 return res;
55889 }
55890
55891 SWIGINTERN int
55892 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55893 int res = 1;
55894 swig_globalvar *var = v->vars;
55895 while (var) {
55896 if (strcmp(var->name,n) == 0) {
55897 res = (*var->set_attr)(p);
55898 break;
55899 }
55900 var = var->next;
55901 }
55902 if (res == 1 && !PyErr_Occurred()) {
55903 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55904 }
55905 return res;
55906 }
55907
55908 SWIGINTERN PyTypeObject*
55909 swig_varlink_type(void) {
55910 static char varlink__doc__[] = "Swig var link object";
55911 static PyTypeObject varlink_type;
55912 static int type_init = 0;
55913 if (!type_init) {
55914 const PyTypeObject tmp
55915 = {
55916 PyObject_HEAD_INIT(NULL)
55917 0, /* Number of items in variable part (ob_size) */
55918 (char *)"swigvarlink", /* Type name (tp_name) */
55919 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55920 0, /* Itemsize (tp_itemsize) */
55921 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55922 (printfunc) swig_varlink_print, /* Print (tp_print) */
55923 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55924 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55925 0, /* tp_compare */
55926 (reprfunc) swig_varlink_repr, /* tp_repr */
55927 0, /* tp_as_number */
55928 0, /* tp_as_sequence */
55929 0, /* tp_as_mapping */
55930 0, /* tp_hash */
55931 0, /* tp_call */
55932 (reprfunc)swig_varlink_str, /* tp_str */
55933 0, /* tp_getattro */
55934 0, /* tp_setattro */
55935 0, /* tp_as_buffer */
55936 0, /* tp_flags */
55937 varlink__doc__, /* tp_doc */
55938 0, /* tp_traverse */
55939 0, /* tp_clear */
55940 0, /* tp_richcompare */
55941 0, /* tp_weaklistoffset */
55942 #if PY_VERSION_HEX >= 0x02020000
55943 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55944 #endif
55945 #if PY_VERSION_HEX >= 0x02030000
55946 0, /* tp_del */
55947 #endif
55948 #ifdef COUNT_ALLOCS
55949 0,0,0,0 /* tp_alloc -> tp_next */
55950 #endif
55951 };
55952 varlink_type = tmp;
55953 varlink_type.ob_type = &PyType_Type;
55954 type_init = 1;
55955 }
55956 return &varlink_type;
55957 }
55958
55959 /* Create a variable linking object for use later */
55960 SWIGINTERN PyObject *
55961 SWIG_Python_newvarlink(void) {
55962 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55963 if (result) {
55964 result->vars = 0;
55965 }
55966 return ((PyObject*) result);
55967 }
55968
55969 SWIGINTERN void
55970 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55971 swig_varlinkobject *v = (swig_varlinkobject *) p;
55972 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55973 if (gv) {
55974 size_t size = strlen(name)+1;
55975 gv->name = (char *)malloc(size);
55976 if (gv->name) {
55977 strncpy(gv->name,name,size);
55978 gv->get_attr = get_attr;
55979 gv->set_attr = set_attr;
55980 gv->next = v->vars;
55981 }
55982 }
55983 v->vars = gv;
55984 }
55985
55986 SWIGINTERN PyObject *
55987 SWIG_globals() {
55988 static PyObject *_SWIG_globals = 0;
55989 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55990 return _SWIG_globals;
55991 }
55992
55993 /* -----------------------------------------------------------------------------
55994 * constants/methods manipulation
55995 * ----------------------------------------------------------------------------- */
55996
55997 /* Install Constants */
55998 SWIGINTERN void
55999 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56000 PyObject *obj = 0;
56001 size_t i;
56002 for (i = 0; constants[i].type; ++i) {
56003 switch(constants[i].type) {
56004 case SWIG_PY_POINTER:
56005 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56006 break;
56007 case SWIG_PY_BINARY:
56008 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56009 break;
56010 default:
56011 obj = 0;
56012 break;
56013 }
56014 if (obj) {
56015 PyDict_SetItemString(d, constants[i].name, obj);
56016 Py_DECREF(obj);
56017 }
56018 }
56019 }
56020
56021 /* -----------------------------------------------------------------------------*/
56022 /* Fix SwigMethods to carry the callback ptrs when needed */
56023 /* -----------------------------------------------------------------------------*/
56024
56025 SWIGINTERN void
56026 SWIG_Python_FixMethods(PyMethodDef *methods,
56027 swig_const_info *const_table,
56028 swig_type_info **types,
56029 swig_type_info **types_initial) {
56030 size_t i;
56031 for (i = 0; methods[i].ml_name; ++i) {
56032 const char *c = methods[i].ml_doc;
56033 if (c && (c = strstr(c, "swig_ptr: "))) {
56034 int j;
56035 swig_const_info *ci = 0;
56036 const char *name = c + 10;
56037 for (j = 0; const_table[j].type; ++j) {
56038 if (strncmp(const_table[j].name, name,
56039 strlen(const_table[j].name)) == 0) {
56040 ci = &(const_table[j]);
56041 break;
56042 }
56043 }
56044 if (ci) {
56045 size_t shift = (ci->ptype) - types;
56046 swig_type_info *ty = types_initial[shift];
56047 size_t ldoc = (c - methods[i].ml_doc);
56048 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56049 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56050 if (ndoc) {
56051 char *buff = ndoc;
56052 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56053 if (ptr) {
56054 strncpy(buff, methods[i].ml_doc, ldoc);
56055 buff += ldoc;
56056 strncpy(buff, "swig_ptr: ", 10);
56057 buff += 10;
56058 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56059 methods[i].ml_doc = ndoc;
56060 }
56061 }
56062 }
56063 }
56064 }
56065 }
56066
56067 #ifdef __cplusplus
56068 }
56069 #endif
56070
56071 /* -----------------------------------------------------------------------------*
56072 * Partial Init method
56073 * -----------------------------------------------------------------------------*/
56074
56075 #ifdef __cplusplus
56076 extern "C"
56077 #endif
56078 SWIGEXPORT void SWIG_init(void) {
56079 PyObject *m, *d;
56080
56081 /* Fix SwigMethods to carry the callback ptrs when needed */
56082 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56083
56084 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56085 d = PyModule_GetDict(m);
56086
56087 SWIG_InitializeModule(0);
56088 SWIG_InstallConstants(d,swig_const_table);
56089
56090
56091
56092 #ifndef wxPyUSE_EXPORT
56093 // Make our API structure a CObject so other modules can import it
56094 // from this module.
56095 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56096 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56097 Py_XDECREF(cobj);
56098 #endif
56099
56100 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56101 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56102 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56103 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56104 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56105 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56106 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56107 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56108 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56109 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56110 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56111 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56112 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56113 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56114 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56115 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56116 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56117 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56118 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56119 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56120 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56121 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56122 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56123 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56124 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56125 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56126 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56127 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56128 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56129 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56130 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56131 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56132 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56133 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56134 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56135 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56136 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56137 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56138 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56139 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56140 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56141 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56142 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56143 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56144 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56145 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56146 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56147 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56148 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56149 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56150 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56151 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56152 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56153 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56154 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56155 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56156 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56157 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56158 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56159 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56160 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56161 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56162 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56163 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56164 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56165 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56166 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56167 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56168 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56169 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56170 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56171 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56172 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56173 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56174 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56175 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56176 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56177 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56178 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56179 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56180 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56181 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56182 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56183 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56184 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56185 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56186 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56187 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56188 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56189 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56190 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56191 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56192 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56193 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56194 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56195 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56196 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56197 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56198 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56199 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56200 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56201 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56202 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56203 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56204 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56205 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56206 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56207 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56208 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56209 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56210 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56211 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56212 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56213 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56214 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56215 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56216 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56217 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56218 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56219 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56220 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56221 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56222 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56223 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56224 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56225 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56226 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56227 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56228 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56229 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56230 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56231 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56232 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56233 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56234 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56235 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56236 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56237 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56238 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56239 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56240 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56241 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56242 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56243 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56244 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56245 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56246 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56247 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56248 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56249 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56250 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56251 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56252 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56253 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56254 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56255 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56256 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56257 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56258 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56259 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56260 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56261 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56262 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56263 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56264 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56265 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56266 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56267 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56268 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56269 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56270 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56271 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56272 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56273 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56274 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56275 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56276 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56277 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56278 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56279 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56280 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56281 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56282 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56283 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56284 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56285 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56286 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56287 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56288 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56289 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56290 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56291 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56292 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56293 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56294 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56295 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56296 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56297 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56298 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56299 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56300 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56301 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56302 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56303 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56304 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56305 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56306 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56307 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56308 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56309 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56310 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56311 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56312 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56313 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56314 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56315 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56316 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56317 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56318 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56319 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56320 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56321 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56322 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56323 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56324 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56325 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56326 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56327 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56328 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56329 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56330 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56331 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56332 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56333 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56334 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56335 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56336 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56337 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56338 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56339 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56340 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56341 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56342 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56343 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56344 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56345 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56346 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56347 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56348 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56349 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56350 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56351 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56352 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56353 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56354 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56355 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56356 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56357 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56358 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56359 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56360 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56361 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56362 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56363 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56364 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56365 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56366 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56367 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56368 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56369 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56370 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56371 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56372 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56373 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56374 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56375 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56376 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56377 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56378 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56379 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56380 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56381 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56382 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56383 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56384 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56385 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56386 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56387 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56388 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56389 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56390 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56391 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56392 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56393 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56394 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56395 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56396 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56397 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56398 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56399 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56400 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56401 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56402 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56403 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56404 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56405 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56406 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56407 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56408 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56409 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56410 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56411 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56412 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56413 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56414 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56415 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56416 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56417 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56418 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56419 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56420 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56421 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56422 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56423 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56424 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56425 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56426 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56427 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56428 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56429 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56430 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56431 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56432 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56433 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56434 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56435 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56436 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56437 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56438 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56439 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56440 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56441 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56442 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56443 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56444 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56445 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56446 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56447 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56448 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56449 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56450 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56451 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56452 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56453 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56454 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56455 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56456 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56457 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56458 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56459 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56460 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56461 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56462 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56463 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56464 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56465 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56466 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56467 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56468 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56469 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56470 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56471 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56472 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56473 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56474 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56475 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56476 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56477 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56478 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56479 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56480 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56481 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56482 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56483 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56484 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56485 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56486 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56487 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56488 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56489 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56490 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56491 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56492 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56493 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56494 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56495 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56496 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56497 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56498 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56499 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56509 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56510 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56511 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56512 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56513 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56514 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56515 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56516 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56517 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56519 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56520 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56521 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56523 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56524 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56525 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56526 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56527 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56528 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56529 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56530 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56532 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56533 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56534 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56535 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56536 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56537 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56538 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56539 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56540 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56541 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56542 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56543 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56544 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56545 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56546 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56547 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56548 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56549 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56550 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56551 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56552 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56553 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56554 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56555 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56556 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56557 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56558 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56559 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56560 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56561 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56562 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56563 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56564 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56565 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56566 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56567 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56568 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56569 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56570 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56571 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56572 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56573 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56574 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56575 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56576 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56577 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56578 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56579 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56580 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56581 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56582 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56583 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56584 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56585 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56586 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56587 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56588 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56589 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56590 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56591 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56592 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56593 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56594 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56595 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56596 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56597 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56598 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56599 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56600 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56601 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56602 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56603 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56604 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56605 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56606 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56607 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56608 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56609 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56610 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56611 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56612 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56613 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56614 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56615 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56616 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56617 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56618 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56619 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56620 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56621 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56622 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56623 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56624 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56625 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56626 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56627 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56628 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56629 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56630 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56631 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56632 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56633 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56634 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56635 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56636 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56637 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56638 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56639 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56640 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56641 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56642 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56643 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56644 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56649 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56650 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56651 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56652 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56653 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56654 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56655 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56660 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56662 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56663 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56664 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56665 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56666 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56667 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56668 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56669 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56670 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56671 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56672 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56673 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56674 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56675 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56676 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56677 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56678 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56679 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56680 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56681 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56682 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56683 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56684 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56685 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56686 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56687 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56688 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56689 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56690 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56691 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56692 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56693 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56694 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56695 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56696 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56697 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56698 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56699 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56700 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56701 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56702 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56703 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56704 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56705 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56707 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56708 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56709 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56710 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56711 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56712 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56713 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56714 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56715 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56716 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56717 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56718 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56719 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56720 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56721 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56722 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56723 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56724 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56725 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56726 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56727 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56728 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56729 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56730 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56731 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56732 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56733 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56734 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56735 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56736 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56737 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56738 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56739 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56740 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56741 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56742 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56743 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56744 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56745 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56746 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56747 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56748 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56749 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56750 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56751 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56752 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56753 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56754 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56755 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56756 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56757 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56758 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56759 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56760 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56761 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56762
56763 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56764
56765
56766 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56767
56768 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56769 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56770 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56771 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56772 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56773 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56774 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56775 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56776 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56777 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56778 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56779 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56780 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56781 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56782 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56783 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56784 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56785 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56786 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56787 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56788 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56789 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56790 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56791 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56792 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56793 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56794 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56795 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56796 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56797 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56798 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56799 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56800 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56801 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56802 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56803 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56804 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56805 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56806 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56807 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56808 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56809 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56810 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56811 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56812 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56813 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56814 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56815 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56816 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56817 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56818 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56819 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56820 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56821 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56822 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56823 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56824 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56825 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56826 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56827 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56828 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56829 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56830 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56831 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56832 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56833 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56834 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56835 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56836 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56837 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56838 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56839 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56840 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56841 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56842 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56843 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56844 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56845 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56846 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56847 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56848 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56849 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56850 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56851 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56852 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56853 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56854 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56855 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56856 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56857 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56858 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56859 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56860 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56861 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56862 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56863 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56864 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56865 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56866 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56867 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56868 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56869 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56870 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56871 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56872 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56873 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56874 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56875 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56876 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56877 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56878 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56879 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56880 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56881 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56882 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56883 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56884 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56885 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56886 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56887 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56888 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56889 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56890 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56891 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56892 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56893 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56894 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56895 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56896 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56897 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56898 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56899 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56900 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56901 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56902 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56903 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56904 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56905 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56906 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56907 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56908 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56909 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56910 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56911 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56912 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56913 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56914 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56915 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56916 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56917 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56918 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56919 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56920 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56921 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56922 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56923 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56924 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56925 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56926 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56927 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56928 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56929 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56930 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56931 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56932 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56933 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56934 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56935 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56936 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56937 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56938 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56939 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56940 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56941 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56942 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56943 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56944 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56945 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56946 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56947 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56948 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56949 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56950 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56951 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56952 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56953 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56954 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56955 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56956 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56957 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56958 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56959 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56960 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56961 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56962 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56963 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56964 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56965 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56966 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56967 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56968 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56969 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56970 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56971 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56972 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56973 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56974 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56975 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56976 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56977 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56978 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56979 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56980
56981 // Initialize threading, some globals and such
56982 __wxPyPreStart(d);
56983
56984
56985 // Although these are defined in __version__ they need to be here too so
56986 // that an assert can be done to ensure that the wxPython and the wxWindows
56987 // versions match.
56988 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56989 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56990 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56991
56992 }
56993
wxWidgets (Impactor)