]> 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
Added wxCB_FILENAME
[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_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981
2982 #include <float.h>
2983
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 SWIGINTERN int
2997 SWIG_AsVal_float (PyObject * obj, float *val)
2998 {
2999 double v;
3000 int res = SWIG_AsVal_double (obj, &v);
3001 if (SWIG_IsOK(res)) {
3002 if ((v < -FLT_MAX || v > FLT_MAX)) {
3003 return SWIG_OverflowError;
3004 } else {
3005 if (val) *val = static_cast< float >(v);
3006 }
3007 }
3008 return res;
3009 }
3010
3011 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3013 PyObject* tup = PyTuple_New(2);
3014 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3015 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3016 wxPyEndBlockThreads(blocked);
3017 return tup;
3018 }
3019
3020 #define SWIG_From_double PyFloat_FromDouble
3021
3022 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3023 wxRealPoint temp, *obj = &temp;
3024 if ( other == Py_None ) return false;
3025 if ( ! wxRealPoint_helper(other, &obj) ) {
3026 PyErr_Clear();
3027 return false;
3028 }
3029 return self->operator==(*obj);
3030 }
3031 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3032 wxRealPoint temp, *obj = &temp;
3033 if ( other == Py_None ) return true;
3034 if ( ! wxRealPoint_helper(other, &obj)) {
3035 PyErr_Clear();
3036 return true;
3037 }
3038 return self->operator!=(*obj);
3039 }
3040 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3041 self->x = x;
3042 self->y = y;
3043 }
3044 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3046 PyObject* tup = PyTuple_New(2);
3047 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3048 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3049 wxPyEndBlockThreads(blocked);
3050 return tup;
3051 }
3052 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3053 wxPoint temp, *obj = &temp;
3054 if ( other == Py_None ) return false;
3055 if ( ! wxPoint_helper(other, &obj) ) {
3056 PyErr_Clear();
3057 return false;
3058 }
3059 return self->operator==(*obj);
3060 }
3061 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3062 wxPoint temp, *obj = &temp;
3063 if ( other == Py_None ) return true;
3064 if ( ! wxPoint_helper(other, &obj)) {
3065 PyErr_Clear();
3066 return true;
3067 }
3068 return self->operator!=(*obj);
3069 }
3070 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3071 self->x = x;
3072 self->y = y;
3073 }
3074 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3076 PyObject* tup = PyTuple_New(2);
3077 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3078 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3079 wxPyEndBlockThreads(blocked);
3080 return tup;
3081 }
3082 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3083 wxRect temp, *obj = &temp;
3084 if ( other == Py_None ) return false;
3085 if ( ! wxRect_helper(other, &obj) ) {
3086 PyErr_Clear();
3087 return false;
3088 }
3089 return self->operator==(*obj);
3090 }
3091 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3092 wxRect temp, *obj = &temp;
3093 if ( other == Py_None ) return true;
3094 if ( ! wxRect_helper(other, &obj)) {
3095 PyErr_Clear();
3096 return true;
3097 }
3098 return self->operator!=(*obj);
3099 }
3100 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3101 self->x = x;
3102 self->y = y;
3103 self->width = width;
3104 self->height = height;
3105 }
3106 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3108 PyObject* tup = PyTuple_New(4);
3109 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3110 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3111 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3112 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3113 wxPyEndBlockThreads(blocked);
3114 return tup;
3115 }
3116
3117 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3118 wxRegion reg1(*r1);
3119 wxRegion reg2(*r2);
3120 wxRect dest(0,0,0,0);
3121 PyObject* obj;
3122
3123 reg1.Intersect(reg2);
3124 dest = reg1.GetBox();
3125
3126 if (dest != wxRect(0,0,0,0)) {
3127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3128 wxRect* newRect = new wxRect(dest);
3129 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3130 wxPyEndBlockThreads(blocked);
3131 return obj;
3132 }
3133 Py_INCREF(Py_None);
3134 return Py_None;
3135 }
3136
3137 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3138 wxPoint2D temp, *obj = &temp;
3139 if ( other == Py_None ) return false;
3140 if ( ! wxPoint2D_helper(other, &obj) ) {
3141 PyErr_Clear();
3142 return false;
3143 }
3144 return self->operator==(*obj);
3145 }
3146 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3147 wxPoint2D temp, *obj = &temp;
3148 if ( other == Py_None ) return true;
3149 if ( ! wxPoint2D_helper(other, &obj)) {
3150 PyErr_Clear();
3151 return true;
3152 }
3153 return self->operator!=(*obj);
3154 }
3155 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3156 self->m_x = x;
3157 self->m_y = y;
3158 }
3159 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3163 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167
3168 #include "wx/wxPython/pyistream.h"
3169
3170 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3171 wxInputStream* wxis = wxPyCBInputStream::create(p);
3172 if (wxis)
3173 return new wxPyInputStream(wxis);
3174 else
3175 return NULL;
3176 }
3177
3178 SWIGINTERN swig_type_info*
3179 SWIG_pchar_descriptor()
3180 {
3181 static int init = 0;
3182 static swig_type_info* info = 0;
3183 if (!init) {
3184 info = SWIG_TypeQuery("_p_char");
3185 init = 1;
3186 }
3187 return info;
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject *
3192 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3193 {
3194 if (carray) {
3195 if (size > INT_MAX) {
3196 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3197 return pchar_descriptor ?
3198 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3199 } else {
3200 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3201 }
3202 } else {
3203 return SWIG_Py_Void();
3204 }
3205 }
3206
3207
3208 SWIGINTERNINLINE PyObject *
3209 SWIG_From_char (char c)
3210 {
3211 return SWIG_FromCharPtrAndSize(&c,1);
3212 }
3213
3214
3215 SWIGINTERNINLINE PyObject*
3216 SWIG_From_unsigned_SS_long (unsigned long value)
3217 {
3218 return (value > LONG_MAX) ?
3219 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3220 }
3221
3222
3223 SWIGINTERNINLINE PyObject *
3224 SWIG_From_size_t (size_t value)
3225 {
3226 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3227 }
3228
3229
3230 SWIGINTERN int
3231 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3232 {
3233 if (PyString_Check(obj)) {
3234 char *cstr; Py_ssize_t len;
3235 PyString_AsStringAndSize(obj, &cstr, &len);
3236 if (cptr) {
3237 if (alloc) {
3238 /*
3239 In python the user should not be able to modify the inner
3240 string representation. To warranty that, if you define
3241 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3242 buffer is always returned.
3243
3244 The default behavior is just to return the pointer value,
3245 so, be careful.
3246 */
3247 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3248 if (*alloc != SWIG_OLDOBJ)
3249 #else
3250 if (*alloc == SWIG_NEWOBJ)
3251 #endif
3252 {
3253 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3254 *alloc = SWIG_NEWOBJ;
3255 }
3256 else {
3257 *cptr = cstr;
3258 *alloc = SWIG_OLDOBJ;
3259 }
3260 } else {
3261 *cptr = PyString_AsString(obj);
3262 }
3263 }
3264 if (psize) *psize = len + 1;
3265 return SWIG_OK;
3266 } else {
3267 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3268 if (pchar_descriptor) {
3269 void* vptr = 0;
3270 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3271 if (cptr) *cptr = (char *) vptr;
3272 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3273 if (alloc) *alloc = SWIG_OLDOBJ;
3274 return SWIG_OK;
3275 }
3276 }
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3284 {
3285 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3286 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3287 if (SWIG_IsOK(res)) {
3288 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3289 if (csize <= size) {
3290 if (val) {
3291 if (csize) memcpy(val, cptr, csize*sizeof(char));
3292 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3293 }
3294 if (alloc == SWIG_NEWOBJ) {
3295 delete[] cptr;
3296 res = SWIG_DelNewMask(res);
3297 }
3298 return res;
3299 }
3300 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3301 }
3302 return SWIG_TypeError;
3303 }
3304
3305
3306 SWIGINTERN int
3307 SWIG_AsVal_char (PyObject * obj, char *val)
3308 {
3309 int res = SWIG_AsCharArray(obj, val, 1);
3310 if (!SWIG_IsOK(res)) {
3311 long v;
3312 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3313 if (SWIG_IsOK(res)) {
3314 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3315 if (val) *val = static_cast< char >(v);
3316 } else {
3317 res = SWIG_OverflowError;
3318 }
3319 }
3320 }
3321 return res;
3322 }
3323
3324 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3325 // We use only strings for the streams, not unicode
3326 PyObject* str = PyObject_Str(obj);
3327 if (! str) {
3328 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3329 return;
3330 }
3331 self->Write(PyString_AS_STRING(str),
3332 PyString_GET_SIZE(str));
3333 Py_DECREF(str);
3334 }
3335
3336 #include "wx/wxPython/pyistream.h"
3337
3338
3339 class wxPyFileSystemHandler : public wxFileSystemHandler
3340 {
3341 public:
3342 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3343
3344 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3345 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3346 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3347 DEC_PYCALLBACK_STRING__pure(FindNext);
3348
3349 wxString GetProtocol(const wxString& location) {
3350 return wxFileSystemHandler::GetProtocol(location);
3351 }
3352
3353 wxString GetLeftLocation(const wxString& location) {
3354 return wxFileSystemHandler::GetLeftLocation(location);
3355 }
3356
3357 wxString GetAnchor(const wxString& location) {
3358 return wxFileSystemHandler::GetAnchor(location);
3359 }
3360
3361 wxString GetRightLocation(const wxString& location) {
3362 return wxFileSystemHandler::GetRightLocation(location);
3363 }
3364
3365 wxString GetMimeTypeFromExt(const wxString& location) {
3366 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3367 }
3368
3369 PYPRIVATE;
3370 };
3371
3372
3373 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3374 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3375 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3376 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3377
3378
3379 SWIGINTERN int
3380 SWIG_AsVal_bool (PyObject *obj, bool *val)
3381 {
3382 if (obj == Py_True) {
3383 if (val) *val = true;
3384 return SWIG_OK;
3385 } else if (obj == Py_False) {
3386 if (val) *val = false;
3387 return SWIG_OK;
3388 } else {
3389 long v = 0;
3390 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3391 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3392 return res;
3393 }
3394 }
3395
3396 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3397 wxFileName fname = wxFileSystem::URLToFileName(url);
3398 return fname.GetFullPath();
3399 }
3400
3401 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3402 wxImage& image,
3403 long type) {
3404 wxMemoryFSHandler::AddFile(filename, image, type);
3405 }
3406
3407 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3408 const wxBitmap& bitmap,
3409 long type) {
3410 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3411 }
3412
3413 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3414 PyObject* data) {
3415 if (! PyString_Check(data)) {
3416 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3417 "Expected string object"));
3418 return;
3419 }
3420
3421 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3422 void* ptr = (void*)PyString_AsString(data);
3423 size_t size = PyString_Size(data);
3424 wxPyEndBlockThreads(blocked);
3425
3426 wxMemoryFSHandler::AddFile(filename, ptr, size);
3427 }
3428
3429
3430 #include "wx/wxPython/pyistream.h"
3431
3432
3433 SWIGINTERN int
3434 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3435 {
3436 long v = 0;
3437 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3438 return SWIG_TypeError;
3439 }
3440 else if (val)
3441 *val = (unsigned long)v;
3442 return SWIG_OK;
3443 }
3444
3445
3446 SWIGINTERN int
3447 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3448 {
3449 unsigned long v;
3450 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3451 if (SWIG_IsOK(res)) {
3452 if ((v > UCHAR_MAX)) {
3453 return SWIG_OverflowError;
3454 } else {
3455 if (val) *val = static_cast< unsigned char >(v);
3456 }
3457 }
3458 return res;
3459 }
3460
3461
3462 SWIGINTERNINLINE PyObject *
3463 SWIG_From_unsigned_SS_char (unsigned char value)
3464 {
3465 return SWIG_From_unsigned_SS_long (value);
3466 }
3467
3468 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3469 wxImageHistogramEntry e = (*self)[key];
3470 return e.value;
3471 }
3472 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3473 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3474 wxImageHistogramEntry e = (*self)[key];
3475 return e.value;
3476 }
3477 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3478 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3479 colour.Green(),
3480 colour.Blue());
3481 wxImageHistogramEntry e = (*self)[key];
3482 return e.value;
3483 }
3484
3485 typedef unsigned char* buffer;
3486
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3635 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3636 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3638 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3642 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3643 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3644 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3645 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3646 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3647 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3648 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3649
3650 #include <wx/quantize.h>
3651
3652 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3653 return wxQuantize::Quantize(src, dest,
3654 //NULL, // palette
3655 desiredNoColours,
3656 NULL, // eightBitData
3657 flags);
3658 }
3659 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3660 if (PyCallable_Check(func)) {
3661 self->Connect(id, lastId, eventType,
3662 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3663 new wxPyCallback(func));
3664 }
3665 else if (func == Py_None) {
3666 self->Disconnect(id, lastId, eventType,
3667 (wxObjectEventFunction)
3668 &wxPyCallback::EventThunker);
3669 }
3670 else {
3671 wxPyBLOCK_THREADS(
3672 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3673 }
3674 }
3675 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3676 return self->Disconnect(id, lastId, eventType,
3677 (wxObjectEventFunction)
3678 &wxPyCallback::EventThunker);
3679 }
3680 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3681 if (_self && _self != Py_None) {
3682 self->SetClientObject(new wxPyOORClientData(_self, incref));
3683 }
3684 else {
3685 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3686 if (data) {
3687 self->SetClientObject(NULL); // This will delete it too
3688 }
3689 }
3690 }
3691
3692 #if ! wxUSE_HOTKEY
3693 #define wxEVT_HOTKEY -9999
3694 #endif
3695
3696 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3697 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3698 if (data) {
3699 Py_INCREF(data->m_obj);
3700 return data->m_obj;
3701 } else {
3702 Py_INCREF(Py_None);
3703 return Py_None;
3704 }
3705 }
3706 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3707 wxPyClientData* data = new wxPyClientData(clientData);
3708 self->SetClientObject(data);
3709 }
3710 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3711 #if wxUSE_UNICODE
3712 return self->GetUnicodeKey();
3713 #else
3714 return 0;
3715 #endif
3716 }
3717 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3718 #if wxUSE_UNICODE
3719 self->m_uniChar = uniChar;
3720 #endif
3721 }
3722
3723 SWIGINTERNINLINE PyObject *
3724 SWIG_From_unsigned_SS_int (unsigned int value)
3725 {
3726 return SWIG_From_unsigned_SS_long (value);
3727 }
3728
3729
3730 SWIGINTERN int
3731 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3732 {
3733 unsigned long v;
3734 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3735 if (SWIG_IsOK(res)) {
3736 if ((v > UINT_MAX)) {
3737 return SWIG_OverflowError;
3738 } else {
3739 if (val) *val = static_cast< unsigned int >(v);
3740 }
3741 }
3742 return res;
3743 }
3744
3745 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3746 self->m_size = size;
3747 }
3748 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3749 int count = self->GetNumberOfFiles();
3750 wxString* files = self->GetFiles();
3751 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3752 PyObject* list = PyList_New(count);
3753
3754 if (!list) {
3755 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3756 wxPyEndBlockThreads(blocked);
3757 return NULL;
3758 }
3759
3760 for (int i=0; i<count; i++) {
3761 PyList_SetItem(list, i, wx2PyString(files[i]));
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return list;
3765 }
3766
3767
3768 SWIGINTERN wxPyApp *new_wxPyApp(){
3769 wxPythonApp = new wxPyApp();
3770 return wxPythonApp;
3771 }
3772 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3773
3774 void wxApp_CleanUp() {
3775 __wxPyCleanup();
3776 }
3777
3778
3779 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3780
3781
3782
3783
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_FromCharPtr(const char *cptr)
3787 {
3788 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3789 }
3790
3791
3792 #if 0 // #ifdef __WXMAC__
3793
3794 // A dummy class that raises an exception if used...
3795 class wxEventLoop
3796 {
3797 public:
3798 wxEventLoop() { wxPyRaiseNotImplemented(); }
3799 int Run() { return 0; }
3800 void Exit(int rc = 0) {}
3801 bool Pending() const { return false; }
3802 bool Dispatch() { return false; }
3803 bool IsRunning() const { return false; }
3804 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3805 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3806 };
3807
3808 #else
3809
3810 #include <wx/evtloop.h>
3811
3812 #endif
3813
3814
3815
3816 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3817 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3818 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3819 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3820 wxWindowList& list = self->GetChildren();
3821 return wxPy_ConvertList(&list);
3822 }
3823 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3824 #if wxUSE_HOTKEY
3825 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3826 #else
3827 return false;
3828 #endif
3829 }
3830 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3831
3832
3833
3834 return false;
3835
3836 }
3837 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3838 return wxPyGetWinHandle(self);
3839 }
3840 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3841 self->AssociateHandle((WXWidget)handle);
3842 }
3843 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3844
3845 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3846 return wxWindow::FindWindowById(id, parent);
3847 }
3848
3849 wxWindow* wxFindWindowByName( const wxString& name,
3850 const wxWindow *parent = NULL ) {
3851 return wxWindow::FindWindowByName(name, parent);
3852 }
3853
3854 wxWindow* wxFindWindowByLabel( const wxString& label,
3855 const wxWindow *parent = NULL ) {
3856 return wxWindow::FindWindowByLabel(label, parent);
3857 }
3858
3859
3860 #ifdef __WXMSW__
3861 #include <wx/msw/private.h> // to get wxGetWindowId
3862 #endif
3863
3864
3865 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3866 #ifdef __WXMSW__
3867 WXHWND hWnd = (WXHWND)_hWnd;
3868 long id = wxGetWindowId(hWnd);
3869 wxWindow* win = new wxWindow;
3870 if (parent)
3871 parent->AddChild(win);
3872 win->SetEventHandler(win);
3873 win->SetHWND(hWnd);
3874 win->SetId(id);
3875 win->SubclassWin(hWnd);
3876 win->AdoptAttributesFromHWND();
3877 win->SetupColours();
3878 return win;
3879 #else
3880 wxPyRaiseNotImplemented();
3881 return NULL;
3882 #endif
3883 }
3884
3885
3886 PyObject* GetTopLevelWindows() {
3887 return wxPy_ConvertList(&wxTopLevelWindows);
3888 }
3889
3890
3891 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3892 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3894
3895 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3896
3897
3898 SWIGINTERNINLINE int
3899 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3900 {
3901 unsigned long v;
3902 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3903 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3904 return res;
3905 }
3906
3907 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3908 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3909 wxMenuItemList& list = self->GetMenuItems();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3913 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3914 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3915 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3916 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3917 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3918 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3919 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3920 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3921 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3922 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3923 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3924 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3925 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3926 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3927 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3928 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3929 static const wxString wxPyControlNameStr(wxControlNameStr);
3930 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3931 if (clientData) {
3932 wxPyClientData* data = new wxPyClientData(clientData);
3933 return self->Append(item, data);
3934 } else
3935 return self->Append(item);
3936 }
3937 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3938 if (clientData) {
3939 wxPyClientData* data = new wxPyClientData(clientData);
3940 return self->Insert(item, pos, data);
3941 } else
3942 return self->Insert(item, pos);
3943 }
3944 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3945 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3946 if (data) {
3947 Py_INCREF(data->m_obj);
3948 return data->m_obj;
3949 } else {
3950 Py_INCREF(Py_None);
3951 return Py_None;
3952 }
3953 }
3954 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3955 wxPyClientData* data = new wxPyClientData(clientData);
3956 self->SetClientObject(n, data);
3957 }
3958
3959
3960 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3961 wxPyUserData* data = NULL;
3962 if ( userData ) {
3963 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3964 data = new wxPyUserData(userData);
3965 wxPyEndBlockThreads(blocked);
3966 }
3967 return new wxSizerItem(window, proportion, flag, border, data);
3968 }
3969 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3970 wxPyUserData* data = NULL;
3971 if ( userData ) {
3972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3973 data = new wxPyUserData(userData);
3974 wxPyEndBlockThreads(blocked);
3975 }
3976 return new wxSizerItem(width, height, proportion, flag, border, data);
3977 }
3978 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3979 wxPyUserData* data = NULL;
3980 if ( userData ) {
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 data = new wxPyUserData(userData);
3983 wxPyEndBlockThreads(blocked);
3984 }
3985 return new wxSizerItem(sizer, proportion, flag, border, data);
3986 }
3987
3988 SWIGINTERNINLINE PyObject *
3989 SWIG_From_float (float value)
3990 {
3991 return SWIG_From_double (value);
3992 }
3993
3994 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3995 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3996 if (data) {
3997 Py_INCREF(data->m_obj);
3998 return data->m_obj;
3999 } else {
4000 Py_INCREF(Py_None);
4001 return Py_None;
4002 }
4003 }
4004 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 self->SetUserData(data);
4012 }
4013
4014 // Figure out the type of the sizer item
4015
4016 struct wxPySizerItemInfo {
4017 wxPySizerItemInfo()
4018 : window(NULL), sizer(NULL), gotSize(false),
4019 size(wxDefaultSize), gotPos(false), pos(-1)
4020 {}
4021
4022 wxWindow* window;
4023 wxSizer* sizer;
4024 bool gotSize;
4025 wxSize size;
4026 bool gotPos;
4027 int pos;
4028 };
4029
4030 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4031
4032 wxPySizerItemInfo info;
4033 wxSize size;
4034 wxSize* sizePtr = &size;
4035
4036 // Find out what the type of the item is
4037 // try wxWindow
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4039 PyErr_Clear();
4040 info.window = NULL;
4041
4042 // try wxSizer
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4044 PyErr_Clear();
4045 info.sizer = NULL;
4046
4047 // try wxSize or (w,h)
4048 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4049 info.size = *sizePtr;
4050 info.gotSize = true;
4051 }
4052
4053 // or a single int
4054 if (checkIdx && PyInt_Check(item)) {
4055 info.pos = PyInt_AsLong(item);
4056 info.gotPos = true;
4057 }
4058 }
4059 }
4060
4061 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4062 // no expected type, figure out what kind of error message to generate
4063 if ( !checkSize && !checkIdx )
4064 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4065 else if ( checkSize && !checkIdx )
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4067 else if ( !checkSize && checkIdx)
4068 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4069 else
4070 // can this one happen?
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4072 }
4073
4074 return info;
4075 }
4076
4077 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4078 if (!self->GetClientObject())
4079 self->SetClientObject(new wxPyOORClientData(_self));
4080 }
4081 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4082
4083 wxPyUserData* data = NULL;
4084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4086 if ( userData && (info.window || info.sizer || info.gotSize) )
4087 data = new wxPyUserData(userData);
4088 if ( info.sizer )
4089 PyObject_SetAttrString(item,"thisown",Py_False);
4090 wxPyEndBlockThreads(blocked);
4091
4092 // Now call the real Add method if a valid item type was found
4093 if ( info.window )
4094 return self->Add(info.window, proportion, flag, border, data);
4095 else if ( info.sizer )
4096 return self->Add(info.sizer, proportion, flag, border, data);
4097 else if (info.gotSize)
4098 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4099 proportion, flag, border, data);
4100 else
4101 return NULL;
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4104
4105 wxPyUserData* data = NULL;
4106 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4107 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4108 if ( userData && (info.window || info.sizer || info.gotSize) )
4109 data = new wxPyUserData(userData);
4110 if ( info.sizer )
4111 PyObject_SetAttrString(item,"thisown",Py_False);
4112 wxPyEndBlockThreads(blocked);
4113
4114 // Now call the real Insert method if a valid item type was found
4115 if ( info.window )
4116 return self->Insert(before, info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Insert(before, info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Prepend method if a valid item type was found
4137 if ( info.window )
4138 return self->Prepend(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Prepend(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4150 wxPyEndBlockThreads(blocked);
4151 if ( info.window )
4152 return self->Remove(info.window);
4153 else if ( info.sizer )
4154 return self->Remove(info.sizer);
4155 else if ( info.gotPos )
4156 return self->Remove(info.pos);
4157 else
4158 return false;
4159 }
4160 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4163 wxPyEndBlockThreads(blocked);
4164 if ( info.window )
4165 return self->Detach(info.window);
4166 else if ( info.sizer )
4167 return self->Detach(info.sizer);
4168 else if ( info.gotPos )
4169 return self->Detach(info.pos);
4170 else
4171 return false;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4176 wxPyEndBlockThreads(blocked);
4177 if ( info.window )
4178 return self->GetItem(info.window);
4179 else if ( info.sizer )
4180 return self->GetItem(info.sizer);
4181 else if ( info.gotPos )
4182 return self->GetItem(info.pos);
4183 else
4184 return NULL;
4185 }
4186 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 self->SetItemMinSize(info.window, size);
4192 else if ( info.sizer )
4193 self->SetItemMinSize(info.sizer, size);
4194 else if ( info.gotPos )
4195 self->SetItemMinSize(info.pos, size);
4196 }
4197 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4198 wxSizerItemList& list = self->GetChildren();
4199 return wxPy_ConvertList(&list);
4200 }
4201 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4204 wxPyEndBlockThreads(blocked);
4205 if ( info.window )
4206 return self->Show(info.window, show, recursive);
4207 else if ( info.sizer )
4208 return self->Show(info.sizer, show, recursive);
4209 else if ( info.gotPos )
4210 return self->Show(info.pos, show);
4211 else
4212 return false;
4213 }
4214 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4216 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4217 wxPyEndBlockThreads(blocked);
4218 if ( info.window )
4219 return self->IsShown(info.window);
4220 else if ( info.sizer )
4221 return self->IsShown(info.sizer);
4222 else if ( info.gotPos )
4223 return self->IsShown(info.pos);
4224 else
4225 return false;
4226 }
4227
4228 // See pyclasses.h
4229 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4230 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4231 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4232
4233
4234
4235
4236 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4237 {
4238 if (source == Py_None) {
4239 **obj = wxGBPosition(-1,-1);
4240 return true;
4241 }
4242 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4243 }
4244
4245 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4246 {
4247 if (source == Py_None) {
4248 **obj = wxGBSpan(-1,-1);
4249 return true;
4250 }
4251 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4252 }
4253
4254
4255 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4256 wxGBPosition temp, *obj = &temp;
4257 if ( other == Py_None ) return false;
4258 if ( ! wxGBPosition_helper(other, &obj) ) {
4259 PyErr_Clear();
4260 return false;
4261 }
4262 return self->operator==(*obj);
4263 }
4264 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4265 wxGBPosition temp, *obj = &temp;
4266 if ( other == Py_None ) return true;
4267 if ( ! wxGBPosition_helper(other, &obj)) {
4268 PyErr_Clear();
4269 return true;
4270 }
4271 return self->operator!=(*obj);
4272 }
4273 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4274 self->SetRow(row);
4275 self->SetCol(col);
4276 }
4277 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 PyObject* tup = PyTuple_New(2);
4280 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4281 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4282 wxPyEndBlockThreads(blocked);
4283 return tup;
4284 }
4285 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4286 wxGBSpan temp, *obj = &temp;
4287 if ( other == Py_None ) return false;
4288 if ( ! wxGBSpan_helper(other, &obj) ) {
4289 PyErr_Clear();
4290 return false;
4291 }
4292 return self->operator==(*obj);
4293 }
4294 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4295 wxGBSpan temp, *obj = &temp;
4296 if ( other == Py_None ) return true;
4297 if ( ! wxGBSpan_helper(other, &obj)) {
4298 PyErr_Clear();
4299 return true;
4300 }
4301 return self->operator!=(*obj);
4302 }
4303 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4304 self->SetRowspan(rowspan);
4305 self->SetColspan(colspan);
4306 }
4307 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 PyObject* tup = PyTuple_New(2);
4310 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4311 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4312 wxPyEndBlockThreads(blocked);
4313 return tup;
4314 }
4315 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4316 wxPyUserData* data = NULL;
4317 if ( userData ) {
4318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4319 data = new wxPyUserData(userData);
4320 wxPyEndBlockThreads(blocked);
4321 }
4322 return new wxGBSizerItem(window, pos, span, flag, border, data);
4323 }
4324 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4325 wxPyUserData* data = NULL;
4326 if ( userData ) {
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 data = new wxPyUserData(userData);
4329 wxPyEndBlockThreads(blocked);
4330 }
4331 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4332 }
4333 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4334 wxPyUserData* data = NULL;
4335 if ( userData ) {
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 data = new wxPyUserData(userData);
4338 wxPyEndBlockThreads(blocked);
4339 }
4340 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4341 }
4342 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4343 int row, col;
4344 self->GetEndPos(row, col);
4345 return wxGBPosition(row, col);
4346 }
4347 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4348
4349 wxPyUserData* data = NULL;
4350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4351 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4352 if ( userData && (info.window || info.sizer || info.gotSize) )
4353 data = new wxPyUserData(userData);
4354 if ( info.sizer )
4355 PyObject_SetAttrString(item,"thisown",Py_False);
4356 wxPyEndBlockThreads(blocked);
4357
4358 // Now call the real Add method if a valid item type was found
4359 if ( info.window )
4360 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4361 else if ( info.sizer )
4362 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4363 else if (info.gotSize)
4364 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4365 pos, span, flag, border, data);
4366 return NULL;
4367 }
4368
4369
4370 #ifdef __cplusplus
4371 extern "C" {
4372 #endif
4373 SWIGINTERN int EmptyString_set(PyObject *) {
4374 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4375 return 1;
4376 }
4377
4378
4379 SWIGINTERN PyObject *EmptyString_get(void) {
4380 PyObject *pyobj = 0;
4381
4382 {
4383 #if wxUSE_UNICODE
4384 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4385 #else
4386 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4387 #endif
4388 }
4389 return pyobj;
4390 }
4391
4392
4393 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4394 PyObject *resultobj = 0;
4395 wxObject *arg1 = (wxObject *) 0 ;
4396 wxString result;
4397 void *argp1 = 0 ;
4398 int res1 = 0 ;
4399 PyObject *swig_obj[1] ;
4400
4401 if (!args) SWIG_fail;
4402 swig_obj[0] = args;
4403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4404 if (!SWIG_IsOK(res1)) {
4405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4406 }
4407 arg1 = reinterpret_cast< wxObject * >(argp1);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxObject_GetClassName(arg1);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 {
4415 #if wxUSE_UNICODE
4416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4417 #else
4418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4419 #endif
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428 PyObject *resultobj = 0;
4429 wxObject *arg1 = (wxObject *) 0 ;
4430 void *argp1 = 0 ;
4431 int res1 = 0 ;
4432 PyObject *swig_obj[1] ;
4433
4434 if (!args) SWIG_fail;
4435 swig_obj[0] = args;
4436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4437 if (!SWIG_IsOK(res1)) {
4438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4439 }
4440 arg1 = reinterpret_cast< wxObject * >(argp1);
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxObject_Destroy(arg1);
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 resultobj = SWIG_Py_Void();
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4455 PyObject *obj;
4456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4457 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4458 return SWIG_Py_Void();
4459 }
4460
4461 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 wxSize *arg1 = (wxSize *) 0 ;
4464 int arg2 ;
4465 void *argp1 = 0 ;
4466 int res1 = 0 ;
4467 int val2 ;
4468 int ecode2 = 0 ;
4469 PyObject *swig_obj[2] ;
4470
4471 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4478 if (!SWIG_IsOK(ecode2)) {
4479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4480 }
4481 arg2 = static_cast< int >(val2);
4482 if (arg1) (arg1)->x = arg2;
4483
4484 resultobj = SWIG_Py_Void();
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxSize *arg1 = (wxSize *) 0 ;
4494 int result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4504 }
4505 arg1 = reinterpret_cast< wxSize * >(argp1);
4506 result = (int) ((arg1)->x);
4507 resultobj = SWIG_From_int(static_cast< int >(result));
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 PyObject *resultobj = 0;
4516 wxSize *arg1 = (wxSize *) 0 ;
4517 int arg2 ;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 int val2 ;
4521 int ecode2 = 0 ;
4522 PyObject *swig_obj[2] ;
4523
4524 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4531 if (!SWIG_IsOK(ecode2)) {
4532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4533 }
4534 arg2 = static_cast< int >(val2);
4535 if (arg1) (arg1)->y = arg2;
4536
4537 resultobj = SWIG_Py_Void();
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4545 PyObject *resultobj = 0;
4546 wxSize *arg1 = (wxSize *) 0 ;
4547 int result;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550 PyObject *swig_obj[1] ;
4551
4552 if (!args) SWIG_fail;
4553 swig_obj[0] = args;
4554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 result = (int) ((arg1)->y);
4560 resultobj = SWIG_From_int(static_cast< int >(result));
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = 0;
4569 int arg1 = (int) 0 ;
4570 int arg2 = (int) 0 ;
4571 wxSize *result = 0 ;
4572 int val1 ;
4573 int ecode1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char * kwnames[] = {
4579 (char *) "w",(char *) "h", NULL
4580 };
4581
4582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4583 if (obj0) {
4584 ecode1 = SWIG_AsVal_int(obj0, &val1);
4585 if (!SWIG_IsOK(ecode1)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4587 }
4588 arg1 = static_cast< int >(val1);
4589 }
4590 if (obj1) {
4591 ecode2 = SWIG_AsVal_int(obj1, &val2);
4592 if (!SWIG_IsOK(ecode2)) {
4593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4594 }
4595 arg2 = static_cast< int >(val2);
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (wxSize *)new wxSize(arg1,arg2);
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4604 return resultobj;
4605 fail:
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4611 PyObject *resultobj = 0;
4612 wxSize *arg1 = (wxSize *) 0 ;
4613 void *argp1 = 0 ;
4614 int res1 = 0 ;
4615 PyObject *swig_obj[1] ;
4616
4617 if (!args) SWIG_fail;
4618 swig_obj[0] = args;
4619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4620 if (!SWIG_IsOK(res1)) {
4621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4622 }
4623 arg1 = reinterpret_cast< wxSize * >(argp1);
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 delete arg1;
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxSize *arg1 = (wxSize *) 0 ;
4641 PyObject *arg2 = (PyObject *) 0 ;
4642 bool result;
4643 void *argp1 = 0 ;
4644 int res1 = 0 ;
4645 PyObject * obj0 = 0 ;
4646 PyObject * obj1 = 0 ;
4647 char * kwnames[] = {
4648 (char *) "self",(char *) "other", NULL
4649 };
4650
4651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4653 if (!SWIG_IsOK(res1)) {
4654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4655 }
4656 arg1 = reinterpret_cast< wxSize * >(argp1);
4657 arg2 = obj1;
4658 {
4659 result = (bool)wxSize___eq__(arg1,arg2);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 {
4663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4664 }
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 PyObject *arg2 = (PyObject *) 0 ;
4675 bool result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "other", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 arg2 = obj1;
4691 {
4692 result = (bool)wxSize___ne__(arg1,arg2);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 {
4696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4697 }
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = 0;
4706 wxSize *arg1 = (wxSize *) 0 ;
4707 wxSize *arg2 = 0 ;
4708 wxSize result;
4709 void *argp1 = 0 ;
4710 int res1 = 0 ;
4711 wxSize temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "self",(char *) "sz", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4720 if (!SWIG_IsOK(res1)) {
4721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4722 }
4723 arg1 = reinterpret_cast< wxSize * >(argp1);
4724 {
4725 arg2 = &temp2;
4726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (arg1)->operator +((wxSize const &)*arg2);
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 wxSize *arg2 = 0 ;
4745 wxSize result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 wxSize temp2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "sz", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 {
4762 arg2 = &temp2;
4763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (arg1)->operator -((wxSize const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj = 0;
4780 wxSize *arg1 = (wxSize *) 0 ;
4781 wxSize *arg2 = 0 ;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 wxSize temp2 ;
4785 PyObject * obj0 = 0 ;
4786 PyObject * obj1 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "sz", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4795 }
4796 arg1 = reinterpret_cast< wxSize * >(argp1);
4797 {
4798 arg2 = &temp2;
4799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->IncTo((wxSize const &)*arg2);
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_Py_Void();
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = 0;
4816 wxSize *arg1 = (wxSize *) 0 ;
4817 wxSize *arg2 = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char * kwnames[] = {
4824 (char *) "self",(char *) "sz", NULL
4825 };
4826
4827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4831 }
4832 arg1 = reinterpret_cast< wxSize * >(argp1);
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 (arg1)->DecTo((wxSize const &)*arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 resultobj = SWIG_Py_Void();
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj = 0;
4852 wxSize *arg1 = (wxSize *) 0 ;
4853 float arg2 ;
4854 float arg3 ;
4855 void *argp1 = 0 ;
4856 int res1 = 0 ;
4857 float val2 ;
4858 int ecode2 = 0 ;
4859 float val3 ;
4860 int ecode3 = 0 ;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 PyObject * obj2 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4872 }
4873 arg1 = reinterpret_cast< wxSize * >(argp1);
4874 ecode2 = SWIG_AsVal_float(obj1, &val2);
4875 if (!SWIG_IsOK(ecode2)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4877 }
4878 arg2 = static_cast< float >(val2);
4879 ecode3 = SWIG_AsVal_float(obj2, &val3);
4880 if (!SWIG_IsOK(ecode3)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4882 }
4883 arg3 = static_cast< float >(val3);
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 (arg1)->Scale(arg2,arg3);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_Py_Void();
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = 0;
4899 wxSize *arg1 = (wxSize *) 0 ;
4900 int arg2 ;
4901 int arg3 ;
4902 void *argp1 = 0 ;
4903 int res1 = 0 ;
4904 int val2 ;
4905 int ecode2 = 0 ;
4906 int val3 ;
4907 int ecode3 = 0 ;
4908 PyObject * obj0 = 0 ;
4909 PyObject * obj1 = 0 ;
4910 PyObject * obj2 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "self",(char *) "w",(char *) "h", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4917 if (!SWIG_IsOK(res1)) {
4918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4919 }
4920 arg1 = reinterpret_cast< wxSize * >(argp1);
4921 ecode2 = SWIG_AsVal_int(obj1, &val2);
4922 if (!SWIG_IsOK(ecode2)) {
4923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4924 }
4925 arg2 = static_cast< int >(val2);
4926 ecode3 = SWIG_AsVal_int(obj2, &val3);
4927 if (!SWIG_IsOK(ecode3)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4929 }
4930 arg3 = static_cast< int >(val3);
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 (arg1)->Set(arg2,arg3);
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 resultobj = SWIG_Py_Void();
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj = 0;
4946 wxSize *arg1 = (wxSize *) 0 ;
4947 int arg2 ;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 int val2 ;
4951 int ecode2 = 0 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 char * kwnames[] = {
4955 (char *) "self",(char *) "w", NULL
4956 };
4957
4958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4960 if (!SWIG_IsOK(res1)) {
4961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4962 }
4963 arg1 = reinterpret_cast< wxSize * >(argp1);
4964 ecode2 = SWIG_AsVal_int(obj1, &val2);
4965 if (!SWIG_IsOK(ecode2)) {
4966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4967 }
4968 arg2 = static_cast< int >(val2);
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 (arg1)->SetWidth(arg2);
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 resultobj = SWIG_Py_Void();
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj = 0;
4984 wxSize *arg1 = (wxSize *) 0 ;
4985 int arg2 ;
4986 void *argp1 = 0 ;
4987 int res1 = 0 ;
4988 int val2 ;
4989 int ecode2 = 0 ;
4990 PyObject * obj0 = 0 ;
4991 PyObject * obj1 = 0 ;
4992 char * kwnames[] = {
4993 (char *) "self",(char *) "h", NULL
4994 };
4995
4996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5000 }
5001 arg1 = reinterpret_cast< wxSize * >(argp1);
5002 ecode2 = SWIG_AsVal_int(obj1, &val2);
5003 if (!SWIG_IsOK(ecode2)) {
5004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5005 }
5006 arg2 = static_cast< int >(val2);
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 (arg1)->SetHeight(arg2);
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 int result;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 PyObject *swig_obj[1] ;
5027
5028 if (!args) SWIG_fail;
5029 swig_obj[0] = args;
5030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5031 if (!SWIG_IsOK(res1)) {
5032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5033 }
5034 arg1 = reinterpret_cast< wxSize * >(argp1);
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)((wxSize const *)arg1)->GetWidth();
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 resultobj = SWIG_From_int(static_cast< int >(result));
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5049 PyObject *resultobj = 0;
5050 wxSize *arg1 = (wxSize *) 0 ;
5051 int result;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 PyObject *swig_obj[1] ;
5055
5056 if (!args) SWIG_fail;
5057 swig_obj[0] = args;
5058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5059 if (!SWIG_IsOK(res1)) {
5060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5061 }
5062 arg1 = reinterpret_cast< wxSize * >(argp1);
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (int)((wxSize const *)arg1)->GetHeight();
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_From_int(static_cast< int >(result));
5070 return resultobj;
5071 fail:
5072 return NULL;
5073 }
5074
5075
5076 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5077 PyObject *resultobj = 0;
5078 wxSize *arg1 = (wxSize *) 0 ;
5079 bool result;
5080 void *argp1 = 0 ;
5081 int res1 = 0 ;
5082 PyObject *swig_obj[1] ;
5083
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5089 }
5090 arg1 = reinterpret_cast< wxSize * >(argp1);
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 wxSize *arg1 = (wxSize *) 0 ;
5109 wxSize *arg2 = 0 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 wxSize temp2 ;
5113 PyObject * obj0 = 0 ;
5114 PyObject * obj1 = 0 ;
5115 char * kwnames[] = {
5116 (char *) "self",(char *) "size", NULL
5117 };
5118
5119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5121 if (!SWIG_IsOK(res1)) {
5122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5123 }
5124 arg1 = reinterpret_cast< wxSize * >(argp1);
5125 {
5126 arg2 = &temp2;
5127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5128 }
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 (arg1)->SetDefaults((wxSize const &)*arg2);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5143 PyObject *resultobj = 0;
5144 wxSize *arg1 = (wxSize *) 0 ;
5145 PyObject *result = 0 ;
5146 void *argp1 = 0 ;
5147 int res1 = 0 ;
5148 PyObject *swig_obj[1] ;
5149
5150 if (!args) SWIG_fail;
5151 swig_obj[0] = args;
5152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5153 if (!SWIG_IsOK(res1)) {
5154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5155 }
5156 arg1 = reinterpret_cast< wxSize * >(argp1);
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 result = (PyObject *)wxSize_Get(arg1);
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = result;
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5171 PyObject *obj;
5172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5173 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5174 return SWIG_Py_Void();
5175 }
5176
5177 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 return SWIG_Python_InitShadowInstance(args);
5179 }
5180
5181 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 PyObject *resultobj = 0;
5183 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5184 double arg2 ;
5185 void *argp1 = 0 ;
5186 int res1 = 0 ;
5187 double val2 ;
5188 int ecode2 = 0 ;
5189 PyObject *swig_obj[2] ;
5190
5191 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5195 }
5196 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5197 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5198 if (!SWIG_IsOK(ecode2)) {
5199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5200 }
5201 arg2 = static_cast< double >(val2);
5202 if (arg1) (arg1)->x = arg2;
5203
5204 resultobj = SWIG_Py_Void();
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5212 PyObject *resultobj = 0;
5213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5214 double result;
5215 void *argp1 = 0 ;
5216 int res1 = 0 ;
5217 PyObject *swig_obj[1] ;
5218
5219 if (!args) SWIG_fail;
5220 swig_obj[0] = args;
5221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5222 if (!SWIG_IsOK(res1)) {
5223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5224 }
5225 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5226 result = (double) ((arg1)->x);
5227 resultobj = SWIG_From_double(static_cast< double >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5237 double arg2 ;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 double val2 ;
5241 int ecode2 = 0 ;
5242 PyObject *swig_obj[2] ;
5243
5244 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5246 if (!SWIG_IsOK(res1)) {
5247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5248 }
5249 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5250 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5251 if (!SWIG_IsOK(ecode2)) {
5252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5253 }
5254 arg2 = static_cast< double >(val2);
5255 if (arg1) (arg1)->y = arg2;
5256
5257 resultobj = SWIG_Py_Void();
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265 PyObject *resultobj = 0;
5266 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5267 double result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 PyObject *swig_obj[1] ;
5271
5272 if (!args) SWIG_fail;
5273 swig_obj[0] = args;
5274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5277 }
5278 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5279 result = (double) ((arg1)->y);
5280 resultobj = SWIG_From_double(static_cast< double >(result));
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = 0;
5289 double arg1 = (double) 0.0 ;
5290 double arg2 = (double) 0.0 ;
5291 wxRealPoint *result = 0 ;
5292 double val1 ;
5293 int ecode1 = 0 ;
5294 double val2 ;
5295 int ecode2 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 PyObject * obj1 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "x",(char *) "y", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5303 if (obj0) {
5304 ecode1 = SWIG_AsVal_double(obj0, &val1);
5305 if (!SWIG_IsOK(ecode1)) {
5306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5307 }
5308 arg1 = static_cast< double >(val1);
5309 }
5310 if (obj1) {
5311 ecode2 = SWIG_AsVal_double(obj1, &val2);
5312 if (!SWIG_IsOK(ecode2)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5314 }
5315 arg2 = static_cast< double >(val2);
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5331 PyObject *resultobj = 0;
5332 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject *swig_obj[1] ;
5336
5337 if (!args) SWIG_fail;
5338 swig_obj[0] = args;
5339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5342 }
5343 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 delete arg1;
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 resultobj = SWIG_Py_Void();
5352 return resultobj;
5353 fail:
5354 return NULL;
5355 }
5356
5357
5358 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5359 PyObject *resultobj = 0;
5360 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5361 PyObject *arg2 = (PyObject *) 0 ;
5362 bool result;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char * kwnames[] = {
5368 (char *) "self",(char *) "other", NULL
5369 };
5370
5371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 arg2 = obj1;
5378 {
5379 result = (bool)wxRealPoint___eq__(arg1,arg2);
5380 if (PyErr_Occurred()) SWIG_fail;
5381 }
5382 {
5383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj = 0;
5393 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5394 PyObject *arg2 = (PyObject *) 0 ;
5395 bool result;
5396 void *argp1 = 0 ;
5397 int res1 = 0 ;
5398 PyObject * obj0 = 0 ;
5399 PyObject * obj1 = 0 ;
5400 char * kwnames[] = {
5401 (char *) "self",(char *) "other", NULL
5402 };
5403
5404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5406 if (!SWIG_IsOK(res1)) {
5407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5408 }
5409 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5410 arg2 = obj1;
5411 {
5412 result = (bool)wxRealPoint___ne__(arg1,arg2);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj = 0;
5426 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5427 wxRealPoint *arg2 = 0 ;
5428 wxRealPoint result;
5429 void *argp1 = 0 ;
5430 int res1 = 0 ;
5431 wxRealPoint temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char * kwnames[] = {
5435 (char *) "self",(char *) "pt", NULL
5436 };
5437
5438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 arg2 = &temp2;
5446 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5447 }
5448 {
5449 PyThreadState* __tstate = wxPyBeginAllowThreads();
5450 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5451 wxPyEndAllowThreads(__tstate);
5452 if (PyErr_Occurred()) SWIG_fail;
5453 }
5454 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5462 PyObject *resultobj = 0;
5463 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5464 wxRealPoint *arg2 = 0 ;
5465 wxRealPoint result;
5466 void *argp1 = 0 ;
5467 int res1 = 0 ;
5468 wxRealPoint temp2 ;
5469 PyObject * obj0 = 0 ;
5470 PyObject * obj1 = 0 ;
5471 char * kwnames[] = {
5472 (char *) "self",(char *) "pt", NULL
5473 };
5474
5475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5477 if (!SWIG_IsOK(res1)) {
5478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5479 }
5480 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5481 {
5482 arg2 = &temp2;
5483 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5484 }
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj = 0;
5500 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5501 double arg2 ;
5502 double arg3 ;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 double val2 ;
5506 int ecode2 = 0 ;
5507 double val3 ;
5508 int ecode3 = 0 ;
5509 PyObject * obj0 = 0 ;
5510 PyObject * obj1 = 0 ;
5511 PyObject * obj2 = 0 ;
5512 char * kwnames[] = {
5513 (char *) "self",(char *) "x",(char *) "y", NULL
5514 };
5515
5516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5518 if (!SWIG_IsOK(res1)) {
5519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5520 }
5521 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5522 ecode2 = SWIG_AsVal_double(obj1, &val2);
5523 if (!SWIG_IsOK(ecode2)) {
5524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5525 }
5526 arg2 = static_cast< double >(val2);
5527 ecode3 = SWIG_AsVal_double(obj2, &val3);
5528 if (!SWIG_IsOK(ecode3)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5530 }
5531 arg3 = static_cast< double >(val3);
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 wxRealPoint_Set(arg1,arg2,arg3);
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 resultobj = SWIG_Py_Void();
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5546 PyObject *resultobj = 0;
5547 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5548 PyObject *result = 0 ;
5549 void *argp1 = 0 ;
5550 int res1 = 0 ;
5551 PyObject *swig_obj[1] ;
5552
5553 if (!args) SWIG_fail;
5554 swig_obj[0] = args;
5555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 result = (PyObject *)wxRealPoint_Get(arg1);
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 resultobj = result;
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5574 PyObject *obj;
5575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5576 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5577 return SWIG_Py_Void();
5578 }
5579
5580 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 return SWIG_Python_InitShadowInstance(args);
5582 }
5583
5584 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586 wxPoint *arg1 = (wxPoint *) 0 ;
5587 int arg2 ;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 int val2 ;
5591 int ecode2 = 0 ;
5592 PyObject *swig_obj[2] ;
5593
5594 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5596 if (!SWIG_IsOK(res1)) {
5597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5598 }
5599 arg1 = reinterpret_cast< wxPoint * >(argp1);
5600 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5601 if (!SWIG_IsOK(ecode2)) {
5602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5603 }
5604 arg2 = static_cast< int >(val2);
5605 if (arg1) (arg1)->x = arg2;
5606
5607 resultobj = SWIG_Py_Void();
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5615 PyObject *resultobj = 0;
5616 wxPoint *arg1 = (wxPoint *) 0 ;
5617 int result;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 PyObject *swig_obj[1] ;
5621
5622 if (!args) SWIG_fail;
5623 swig_obj[0] = args;
5624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5625 if (!SWIG_IsOK(res1)) {
5626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5627 }
5628 arg1 = reinterpret_cast< wxPoint * >(argp1);
5629 result = (int) ((arg1)->x);
5630 resultobj = SWIG_From_int(static_cast< int >(result));
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 int arg2 ;
5641 void *argp1 = 0 ;
5642 int res1 = 0 ;
5643 int val2 ;
5644 int ecode2 = 0 ;
5645 PyObject *swig_obj[2] ;
5646
5647 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5649 if (!SWIG_IsOK(res1)) {
5650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5651 }
5652 arg1 = reinterpret_cast< wxPoint * >(argp1);
5653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5654 if (!SWIG_IsOK(ecode2)) {
5655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5656 }
5657 arg2 = static_cast< int >(val2);
5658 if (arg1) (arg1)->y = arg2;
5659
5660 resultobj = SWIG_Py_Void();
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5668 PyObject *resultobj = 0;
5669 wxPoint *arg1 = (wxPoint *) 0 ;
5670 int result;
5671 void *argp1 = 0 ;
5672 int res1 = 0 ;
5673 PyObject *swig_obj[1] ;
5674
5675 if (!args) SWIG_fail;
5676 swig_obj[0] = args;
5677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxPoint * >(argp1);
5682 result = (int) ((arg1)->y);
5683 resultobj = SWIG_From_int(static_cast< int >(result));
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj = 0;
5692 int arg1 = (int) 0 ;
5693 int arg2 = (int) 0 ;
5694 wxPoint *result = 0 ;
5695 int val1 ;
5696 int ecode1 = 0 ;
5697 int val2 ;
5698 int ecode2 = 0 ;
5699 PyObject * obj0 = 0 ;
5700 PyObject * obj1 = 0 ;
5701 char * kwnames[] = {
5702 (char *) "x",(char *) "y", NULL
5703 };
5704
5705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5706 if (obj0) {
5707 ecode1 = SWIG_AsVal_int(obj0, &val1);
5708 if (!SWIG_IsOK(ecode1)) {
5709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5710 }
5711 arg1 = static_cast< int >(val1);
5712 }
5713 if (obj1) {
5714 ecode2 = SWIG_AsVal_int(obj1, &val2);
5715 if (!SWIG_IsOK(ecode2)) {
5716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5717 }
5718 arg2 = static_cast< int >(val2);
5719 }
5720 {
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 result = (wxPoint *)new wxPoint(arg1,arg2);
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5734 PyObject *resultobj = 0;
5735 wxPoint *arg1 = (wxPoint *) 0 ;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 PyObject *swig_obj[1] ;
5739
5740 if (!args) SWIG_fail;
5741 swig_obj[0] = args;
5742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5743 if (!SWIG_IsOK(res1)) {
5744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5745 }
5746 arg1 = reinterpret_cast< wxPoint * >(argp1);
5747 {
5748 PyThreadState* __tstate = wxPyBeginAllowThreads();
5749 delete arg1;
5750
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_Py_Void();
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj = 0;
5763 wxPoint *arg1 = (wxPoint *) 0 ;
5764 PyObject *arg2 = (PyObject *) 0 ;
5765 bool result;
5766 void *argp1 = 0 ;
5767 int res1 = 0 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "self",(char *) "other", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 arg2 = obj1;
5781 {
5782 result = (bool)wxPoint___eq__(arg1,arg2);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 {
5786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5787 }
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj = 0;
5796 wxPoint *arg1 = (wxPoint *) 0 ;
5797 PyObject *arg2 = (PyObject *) 0 ;
5798 bool result;
5799 void *argp1 = 0 ;
5800 int res1 = 0 ;
5801 PyObject * obj0 = 0 ;
5802 PyObject * obj1 = 0 ;
5803 char * kwnames[] = {
5804 (char *) "self",(char *) "other", NULL
5805 };
5806
5807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5809 if (!SWIG_IsOK(res1)) {
5810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5811 }
5812 arg1 = reinterpret_cast< wxPoint * >(argp1);
5813 arg2 = obj1;
5814 {
5815 result = (bool)wxPoint___ne__(arg1,arg2);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 {
5819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5820 }
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = 0;
5829 wxPoint *arg1 = (wxPoint *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint result;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 wxPoint temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char * kwnames[] = {
5838 (char *) "self",(char *) "pt", NULL
5839 };
5840
5841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 arg2 = &temp2;
5849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 result = (arg1)->operator +((wxPoint const &)*arg2);
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj = 0;
5866 wxPoint *arg1 = (wxPoint *) 0 ;
5867 wxPoint *arg2 = 0 ;
5868 wxPoint result;
5869 void *argp1 = 0 ;
5870 int res1 = 0 ;
5871 wxPoint temp2 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char * kwnames[] = {
5875 (char *) "self",(char *) "pt", NULL
5876 };
5877
5878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5880 if (!SWIG_IsOK(res1)) {
5881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5882 }
5883 arg1 = reinterpret_cast< wxPoint * >(argp1);
5884 {
5885 arg2 = &temp2;
5886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5887 }
5888 {
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 result = (arg1)->operator -((wxPoint const &)*arg2);
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = 0;
5903 wxPoint *arg1 = (wxPoint *) 0 ;
5904 wxPoint *arg2 = 0 ;
5905 wxPoint *result = 0 ;
5906 void *argp1 = 0 ;
5907 int res1 = 0 ;
5908 wxPoint temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char * kwnames[] = {
5912 (char *) "self",(char *) "pt", NULL
5913 };
5914
5915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5919 }
5920 arg1 = reinterpret_cast< wxPoint * >(argp1);
5921 {
5922 arg2 = &temp2;
5923 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5924 }
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 {
5928 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5929 result = (wxPoint *) &_result_ref;
5930 }
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxPoint *arg1 = (wxPoint *) 0 ;
5944 wxPoint *arg2 = 0 ;
5945 wxPoint *result = 0 ;
5946 void *argp1 = 0 ;
5947 int res1 = 0 ;
5948 wxPoint temp2 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char * kwnames[] = {
5952 (char *) "self",(char *) "pt", NULL
5953 };
5954
5955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5957 if (!SWIG_IsOK(res1)) {
5958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5959 }
5960 arg1 = reinterpret_cast< wxPoint * >(argp1);
5961 {
5962 arg2 = &temp2;
5963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5964 }
5965 {
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 {
5968 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5969 result = (wxPoint *) &_result_ref;
5970 }
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = (wxPoint *) 0 ;
5984 long arg2 ;
5985 long arg3 ;
5986 void *argp1 = 0 ;
5987 int res1 = 0 ;
5988 long val2 ;
5989 int ecode2 = 0 ;
5990 long val3 ;
5991 int ecode3 = 0 ;
5992 PyObject * obj0 = 0 ;
5993 PyObject * obj1 = 0 ;
5994 PyObject * obj2 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "x",(char *) "y", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 ecode2 = SWIG_AsVal_long(obj1, &val2);
6006 if (!SWIG_IsOK(ecode2)) {
6007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6008 }
6009 arg2 = static_cast< long >(val2);
6010 ecode3 = SWIG_AsVal_long(obj2, &val3);
6011 if (!SWIG_IsOK(ecode3)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6013 }
6014 arg3 = static_cast< long >(val3);
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 wxPoint_Set(arg1,arg2,arg3);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 resultobj = SWIG_Py_Void();
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029 PyObject *resultobj = 0;
6030 wxPoint *arg1 = (wxPoint *) 0 ;
6031 PyObject *result = 0 ;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject *swig_obj[1] ;
6035
6036 if (!args) SWIG_fail;
6037 swig_obj[0] = args;
6038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6039 if (!SWIG_IsOK(res1)) {
6040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6041 }
6042 arg1 = reinterpret_cast< wxPoint * >(argp1);
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (PyObject *)wxPoint_Get(arg1);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = result;
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6057 PyObject *obj;
6058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6060 return SWIG_Py_Void();
6061 }
6062
6063 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6064 return SWIG_Python_InitShadowInstance(args);
6065 }
6066
6067 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj = 0;
6069 int arg1 = (int) 0 ;
6070 int arg2 = (int) 0 ;
6071 int arg3 = (int) 0 ;
6072 int arg4 = (int) 0 ;
6073 wxRect *result = 0 ;
6074 int val1 ;
6075 int ecode1 = 0 ;
6076 int val2 ;
6077 int ecode2 = 0 ;
6078 int val3 ;
6079 int ecode3 = 0 ;
6080 int val4 ;
6081 int ecode4 = 0 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 PyObject * obj3 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6091 if (obj0) {
6092 ecode1 = SWIG_AsVal_int(obj0, &val1);
6093 if (!SWIG_IsOK(ecode1)) {
6094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6095 }
6096 arg1 = static_cast< int >(val1);
6097 }
6098 if (obj1) {
6099 ecode2 = SWIG_AsVal_int(obj1, &val2);
6100 if (!SWIG_IsOK(ecode2)) {
6101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6102 }
6103 arg2 = static_cast< int >(val2);
6104 }
6105 if (obj2) {
6106 ecode3 = SWIG_AsVal_int(obj2, &val3);
6107 if (!SWIG_IsOK(ecode3)) {
6108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6109 }
6110 arg3 = static_cast< int >(val3);
6111 }
6112 if (obj3) {
6113 ecode4 = SWIG_AsVal_int(obj3, &val4);
6114 if (!SWIG_IsOK(ecode4)) {
6115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6116 }
6117 arg4 = static_cast< int >(val4);
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj = 0;
6134 wxPoint *arg1 = 0 ;
6135 wxPoint *arg2 = 0 ;
6136 wxRect *result = 0 ;
6137 wxPoint temp1 ;
6138 wxPoint temp2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char * kwnames[] = {
6142 (char *) "topLeft",(char *) "bottomRight", NULL
6143 };
6144
6145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6146 {
6147 arg1 = &temp1;
6148 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6149 }
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 wxPoint *arg1 = 0 ;
6170 wxSize *arg2 = 0 ;
6171 wxRect *result = 0 ;
6172 wxPoint temp1 ;
6173 wxSize temp2 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char * kwnames[] = {
6177 (char *) "pos",(char *) "size", NULL
6178 };
6179
6180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6181 {
6182 arg1 = &temp1;
6183 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6184 }
6185 {
6186 arg2 = &temp2;
6187 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6196 return resultobj;
6197 fail:
6198 return NULL;
6199 }
6200
6201
6202 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj = 0;
6204 wxSize *arg1 = 0 ;
6205 wxRect *result = 0 ;
6206 wxSize temp1 ;
6207 PyObject * obj0 = 0 ;
6208 char * kwnames[] = {
6209 (char *) "size", NULL
6210 };
6211
6212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6213 {
6214 arg1 = &temp1;
6215 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6216 }
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6231 PyObject *resultobj = 0;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 void *argp1 = 0 ;
6234 int res1 = 0 ;
6235 PyObject *swig_obj[1] ;
6236
6237 if (!args) SWIG_fail;
6238 swig_obj[0] = args;
6239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6240 if (!SWIG_IsOK(res1)) {
6241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6242 }
6243 arg1 = reinterpret_cast< wxRect * >(argp1);
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 delete arg1;
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_Py_Void();
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6259 PyObject *resultobj = 0;
6260 wxRect *arg1 = (wxRect *) 0 ;
6261 int result;
6262 void *argp1 = 0 ;
6263 int res1 = 0 ;
6264 PyObject *swig_obj[1] ;
6265
6266 if (!args) SWIG_fail;
6267 swig_obj[0] = args;
6268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6269 if (!SWIG_IsOK(res1)) {
6270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6271 }
6272 arg1 = reinterpret_cast< wxRect * >(argp1);
6273 {
6274 PyThreadState* __tstate = wxPyBeginAllowThreads();
6275 result = (int)((wxRect const *)arg1)->GetX();
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 resultobj = SWIG_From_int(static_cast< int >(result));
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj = 0;
6288 wxRect *arg1 = (wxRect *) 0 ;
6289 int arg2 ;
6290 void *argp1 = 0 ;
6291 int res1 = 0 ;
6292 int val2 ;
6293 int ecode2 = 0 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "self",(char *) "x", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6302 if (!SWIG_IsOK(res1)) {
6303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6304 }
6305 arg1 = reinterpret_cast< wxRect * >(argp1);
6306 ecode2 = SWIG_AsVal_int(obj1, &val2);
6307 if (!SWIG_IsOK(ecode2)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6309 }
6310 arg2 = static_cast< int >(val2);
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 (arg1)->SetX(arg2);
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 resultobj = SWIG_Py_Void();
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6325 PyObject *resultobj = 0;
6326 wxRect *arg1 = (wxRect *) 0 ;
6327 int result;
6328 void *argp1 = 0 ;
6329 int res1 = 0 ;
6330 PyObject *swig_obj[1] ;
6331
6332 if (!args) SWIG_fail;
6333 swig_obj[0] = args;
6334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6335 if (!SWIG_IsOK(res1)) {
6336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6337 }
6338 arg1 = reinterpret_cast< wxRect * >(argp1);
6339 {
6340 PyThreadState* __tstate = wxPyBeginAllowThreads();
6341 result = (int)(arg1)->GetY();
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 resultobj = SWIG_From_int(static_cast< int >(result));
6346 return resultobj;
6347 fail:
6348 return NULL;
6349 }
6350
6351
6352 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6353 PyObject *resultobj = 0;
6354 wxRect *arg1 = (wxRect *) 0 ;
6355 int arg2 ;
6356 void *argp1 = 0 ;
6357 int res1 = 0 ;
6358 int val2 ;
6359 int ecode2 = 0 ;
6360 PyObject * obj0 = 0 ;
6361 PyObject * obj1 = 0 ;
6362 char * kwnames[] = {
6363 (char *) "self",(char *) "y", NULL
6364 };
6365
6366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6368 if (!SWIG_IsOK(res1)) {
6369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6370 }
6371 arg1 = reinterpret_cast< wxRect * >(argp1);
6372 ecode2 = SWIG_AsVal_int(obj1, &val2);
6373 if (!SWIG_IsOK(ecode2)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6375 }
6376 arg2 = static_cast< int >(val2);
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 (arg1)->SetY(arg2);
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 resultobj = SWIG_Py_Void();
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6391 PyObject *resultobj = 0;
6392 wxRect *arg1 = (wxRect *) 0 ;
6393 int result;
6394 void *argp1 = 0 ;
6395 int res1 = 0 ;
6396 PyObject *swig_obj[1] ;
6397
6398 if (!args) SWIG_fail;
6399 swig_obj[0] = args;
6400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6401 if (!SWIG_IsOK(res1)) {
6402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6403 }
6404 arg1 = reinterpret_cast< wxRect * >(argp1);
6405 {
6406 PyThreadState* __tstate = wxPyBeginAllowThreads();
6407 result = (int)((wxRect const *)arg1)->GetWidth();
6408 wxPyEndAllowThreads(__tstate);
6409 if (PyErr_Occurred()) SWIG_fail;
6410 }
6411 resultobj = SWIG_From_int(static_cast< int >(result));
6412 return resultobj;
6413 fail:
6414 return NULL;
6415 }
6416
6417
6418 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6419 PyObject *resultobj = 0;
6420 wxRect *arg1 = (wxRect *) 0 ;
6421 int arg2 ;
6422 void *argp1 = 0 ;
6423 int res1 = 0 ;
6424 int val2 ;
6425 int ecode2 = 0 ;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char * kwnames[] = {
6429 (char *) "self",(char *) "w", NULL
6430 };
6431
6432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6434 if (!SWIG_IsOK(res1)) {
6435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6436 }
6437 arg1 = reinterpret_cast< wxRect * >(argp1);
6438 ecode2 = SWIG_AsVal_int(obj1, &val2);
6439 if (!SWIG_IsOK(ecode2)) {
6440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6441 }
6442 arg2 = static_cast< int >(val2);
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 (arg1)->SetWidth(arg2);
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 resultobj = SWIG_Py_Void();
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6457 PyObject *resultobj = 0;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 int result;
6460 void *argp1 = 0 ;
6461 int res1 = 0 ;
6462 PyObject *swig_obj[1] ;
6463
6464 if (!args) SWIG_fail;
6465 swig_obj[0] = args;
6466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6467 if (!SWIG_IsOK(res1)) {
6468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6469 }
6470 arg1 = reinterpret_cast< wxRect * >(argp1);
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (int)((wxRect const *)arg1)->GetHeight();
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_From_int(static_cast< int >(result));
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 int arg2 ;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 int val2 ;
6491 int ecode2 = 0 ;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 char * kwnames[] = {
6495 (char *) "self",(char *) "h", NULL
6496 };
6497
6498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6500 if (!SWIG_IsOK(res1)) {
6501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6502 }
6503 arg1 = reinterpret_cast< wxRect * >(argp1);
6504 ecode2 = SWIG_AsVal_int(obj1, &val2);
6505 if (!SWIG_IsOK(ecode2)) {
6506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6507 }
6508 arg2 = static_cast< int >(val2);
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 (arg1)->SetHeight(arg2);
6512 wxPyEndAllowThreads(__tstate);
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_Py_Void();
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 wxPoint result;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 PyObject *swig_obj[1] ;
6529
6530 if (!args) SWIG_fail;
6531 swig_obj[0] = args;
6532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6533 if (!SWIG_IsOK(res1)) {
6534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6535 }
6536 arg1 = reinterpret_cast< wxRect * >(argp1);
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = ((wxRect const *)arg1)->GetPosition();
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj = 0;
6552 wxRect *arg1 = (wxRect *) 0 ;
6553 wxPoint *arg2 = 0 ;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 wxPoint temp2 ;
6557 PyObject * obj0 = 0 ;
6558 PyObject * obj1 = 0 ;
6559 char * kwnames[] = {
6560 (char *) "self",(char *) "p", NULL
6561 };
6562
6563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 {
6570 arg2 = &temp2;
6571 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 (arg1)->SetPosition((wxPoint const &)*arg2);
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_Py_Void();
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 PyObject *resultobj = 0;
6588 wxRect *arg1 = (wxRect *) 0 ;
6589 wxSize result;
6590 void *argp1 = 0 ;
6591 int res1 = 0 ;
6592 PyObject *swig_obj[1] ;
6593
6594 if (!args) SWIG_fail;
6595 swig_obj[0] = args;
6596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6597 if (!SWIG_IsOK(res1)) {
6598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6599 }
6600 arg1 = reinterpret_cast< wxRect * >(argp1);
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = ((wxRect const *)arg1)->GetSize();
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = 0;
6616 wxRect *arg1 = (wxRect *) 0 ;
6617 wxSize *arg2 = 0 ;
6618 void *argp1 = 0 ;
6619 int res1 = 0 ;
6620 wxSize temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char * kwnames[] = {
6624 (char *) "self",(char *) "s", NULL
6625 };
6626
6627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6629 if (!SWIG_IsOK(res1)) {
6630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6631 }
6632 arg1 = reinterpret_cast< wxRect * >(argp1);
6633 {
6634 arg2 = &temp2;
6635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6636 }
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 (arg1)->SetSize((wxSize const &)*arg2);
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_Py_Void();
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 bool result;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 PyObject *swig_obj[1] ;
6657
6658 if (!args) SWIG_fail;
6659 swig_obj[0] = args;
6660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 PyThreadState* __tstate = wxPyBeginAllowThreads();
6667 result = (bool)((wxRect const *)arg1)->IsEmpty();
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 {
6672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6673 }
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxPoint result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 result = ((wxRect const *)arg1)->GetTopLeft();
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6709 PyObject *resultobj = 0;
6710 wxRect *arg1 = (wxRect *) 0 ;
6711 wxPoint *arg2 = 0 ;
6712 void *argp1 = 0 ;
6713 int res1 = 0 ;
6714 wxPoint temp2 ;
6715 PyObject * obj0 = 0 ;
6716 PyObject * obj1 = 0 ;
6717 char * kwnames[] = {
6718 (char *) "self",(char *) "p", NULL
6719 };
6720
6721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6723 if (!SWIG_IsOK(res1)) {
6724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6725 }
6726 arg1 = reinterpret_cast< wxRect * >(argp1);
6727 {
6728 arg2 = &temp2;
6729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6730 }
6731 {
6732 PyThreadState* __tstate = wxPyBeginAllowThreads();
6733 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 resultobj = SWIG_Py_Void();
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6745 PyObject *resultobj = 0;
6746 wxRect *arg1 = (wxRect *) 0 ;
6747 wxPoint result;
6748 void *argp1 = 0 ;
6749 int res1 = 0 ;
6750 PyObject *swig_obj[1] ;
6751
6752 if (!args) SWIG_fail;
6753 swig_obj[0] = args;
6754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6755 if (!SWIG_IsOK(res1)) {
6756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6757 }
6758 arg1 = reinterpret_cast< wxRect * >(argp1);
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = ((wxRect const *)arg1)->GetBottomRight();
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj = 0;
6774 wxRect *arg1 = (wxRect *) 0 ;
6775 wxPoint *arg2 = 0 ;
6776 void *argp1 = 0 ;
6777 int res1 = 0 ;
6778 wxPoint temp2 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "p", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_Py_Void();
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 int result;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 PyObject *swig_obj[1] ;
6815
6816 if (!args) SWIG_fail;
6817 swig_obj[0] = args;
6818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6819 if (!SWIG_IsOK(res1)) {
6820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6821 }
6822 arg1 = reinterpret_cast< wxRect * >(argp1);
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (int)((wxRect const *)arg1)->GetLeft();
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 resultobj = SWIG_From_int(static_cast< int >(result));
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6837 PyObject *resultobj = 0;
6838 wxRect *arg1 = (wxRect *) 0 ;
6839 int result;
6840 void *argp1 = 0 ;
6841 int res1 = 0 ;
6842 PyObject *swig_obj[1] ;
6843
6844 if (!args) SWIG_fail;
6845 swig_obj[0] = args;
6846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6847 if (!SWIG_IsOK(res1)) {
6848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6849 }
6850 arg1 = reinterpret_cast< wxRect * >(argp1);
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (int)((wxRect const *)arg1)->GetTop();
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_From_int(static_cast< int >(result));
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6865 PyObject *resultobj = 0;
6866 wxRect *arg1 = (wxRect *) 0 ;
6867 int result;
6868 void *argp1 = 0 ;
6869 int res1 = 0 ;
6870 PyObject *swig_obj[1] ;
6871
6872 if (!args) SWIG_fail;
6873 swig_obj[0] = args;
6874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6877 }
6878 arg1 = reinterpret_cast< wxRect * >(argp1);
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (int)((wxRect const *)arg1)->GetBottom();
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_From_int(static_cast< int >(result));
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6893 PyObject *resultobj = 0;
6894 wxRect *arg1 = (wxRect *) 0 ;
6895 int result;
6896 void *argp1 = 0 ;
6897 int res1 = 0 ;
6898 PyObject *swig_obj[1] ;
6899
6900 if (!args) SWIG_fail;
6901 swig_obj[0] = args;
6902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = (int)((wxRect const *)arg1)->GetRight();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_From_int(static_cast< int >(result));
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 int arg2 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 int val2 ;
6927 int ecode2 = 0 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "self",(char *) "left", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 ecode2 = SWIG_AsVal_int(obj1, &val2);
6941 if (!SWIG_IsOK(ecode2)) {
6942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6943 }
6944 arg2 = static_cast< int >(val2);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 (arg1)->SetLeft(arg2);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_Py_Void();
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxRect *arg1 = (wxRect *) 0 ;
6961 int arg2 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 int val2 ;
6965 int ecode2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "right", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 ecode2 = SWIG_AsVal_int(obj1, &val2);
6979 if (!SWIG_IsOK(ecode2)) {
6980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6981 }
6982 arg2 = static_cast< int >(val2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetRight(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int arg2 ;
7000 void *argp1 = 0 ;
7001 int res1 = 0 ;
7002 int val2 ;
7003 int ecode2 = 0 ;
7004 PyObject * obj0 = 0 ;
7005 PyObject * obj1 = 0 ;
7006 char * kwnames[] = {
7007 (char *) "self",(char *) "top", NULL
7008 };
7009
7010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7014 }
7015 arg1 = reinterpret_cast< wxRect * >(argp1);
7016 ecode2 = SWIG_AsVal_int(obj1, &val2);
7017 if (!SWIG_IsOK(ecode2)) {
7018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7019 }
7020 arg2 = static_cast< int >(val2);
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 (arg1)->SetTop(arg2);
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_Py_Void();
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int arg2 ;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 int val2 ;
7041 int ecode2 = 0 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char * kwnames[] = {
7045 (char *) "self",(char *) "bottom", NULL
7046 };
7047
7048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7050 if (!SWIG_IsOK(res1)) {
7051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7052 }
7053 arg1 = reinterpret_cast< wxRect * >(argp1);
7054 ecode2 = SWIG_AsVal_int(obj1, &val2);
7055 if (!SWIG_IsOK(ecode2)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7057 }
7058 arg2 = static_cast< int >(val2);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->SetBottom(arg2);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int arg2 ;
7076 int arg3 ;
7077 wxRect *result = 0 ;
7078 void *argp1 = 0 ;
7079 int res1 = 0 ;
7080 int val2 ;
7081 int ecode2 = 0 ;
7082 int val3 ;
7083 int ecode3 = 0 ;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 PyObject * obj2 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "self",(char *) "dx",(char *) "dy", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 ecode2 = SWIG_AsVal_int(obj1, &val2);
7098 if (!SWIG_IsOK(ecode2)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7100 }
7101 arg2 = static_cast< int >(val2);
7102 ecode3 = SWIG_AsVal_int(obj2, &val3);
7103 if (!SWIG_IsOK(ecode3)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7105 }
7106 arg3 = static_cast< int >(val3);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 {
7110 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7111 result = (wxRect *) &_result_ref;
7112 }
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 wxRect *result = 0 ;
7129 void *argp1 = 0 ;
7130 int res1 = 0 ;
7131 int val2 ;
7132 int ecode2 = 0 ;
7133 int val3 ;
7134 int ecode3 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 PyObject * obj2 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "dx",(char *) "dy", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 ecode3 = SWIG_AsVal_int(obj2, &val3);
7154 if (!SWIG_IsOK(ecode3)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7156 }
7157 arg3 = static_cast< int >(val3);
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 {
7161 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7162 result = (wxRect *) &_result_ref;
7163 }
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxRect *arg1 = (wxRect *) 0 ;
7177 int arg2 ;
7178 int arg3 ;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 int val2 ;
7182 int ecode2 = 0 ;
7183 int val3 ;
7184 int ecode3 = 0 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 PyObject * obj2 = 0 ;
7188 char * kwnames[] = {
7189 (char *) "self",(char *) "dx",(char *) "dy", NULL
7190 };
7191
7192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7196 }
7197 arg1 = reinterpret_cast< wxRect * >(argp1);
7198 ecode2 = SWIG_AsVal_int(obj1, &val2);
7199 if (!SWIG_IsOK(ecode2)) {
7200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7201 }
7202 arg2 = static_cast< int >(val2);
7203 ecode3 = SWIG_AsVal_int(obj2, &val3);
7204 if (!SWIG_IsOK(ecode3)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7206 }
7207 arg3 = static_cast< int >(val3);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 (arg1)->Offset(arg2,arg3);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_Py_Void();
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxRect *arg1 = (wxRect *) 0 ;
7224 wxPoint *arg2 = 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 wxPoint temp2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "pt", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 {
7241 arg2 = &temp2;
7242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7243 }
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 (arg1)->Offset((wxPoint const &)*arg2);
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_Py_Void();
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 wxRect result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (arg1)->Intersect((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 wxRect *arg2 = 0 ;
7298 wxRect result;
7299 void *argp1 = 0 ;
7300 int res1 = 0 ;
7301 wxRect temp2 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "rect", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 {
7315 arg2 = &temp2;
7316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (arg1)->Union((wxRect const &)*arg2);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj = 0;
7333 wxRect *arg1 = (wxRect *) 0 ;
7334 wxRect *arg2 = 0 ;
7335 wxRect result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 wxRect temp2 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "rect", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7349 }
7350 arg1 = reinterpret_cast< wxRect * >(argp1);
7351 {
7352 arg2 = &temp2;
7353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7354 }
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 wxRect *arg2 = 0 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 wxRect temp2 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char * kwnames[] = {
7379 (char *) "self",(char *) "rect", NULL
7380 };
7381
7382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7386 }
7387 arg1 = reinterpret_cast< wxRect * >(argp1);
7388 {
7389 arg2 = &temp2;
7390 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7391 }
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 {
7395 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7396 result = (wxRect *) &_result_ref;
7397 }
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj = 0;
7410 wxRect *arg1 = (wxRect *) 0 ;
7411 PyObject *arg2 = (PyObject *) 0 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 char * kwnames[] = {
7418 (char *) "self",(char *) "other", NULL
7419 };
7420
7421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7423 if (!SWIG_IsOK(res1)) {
7424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7425 }
7426 arg1 = reinterpret_cast< wxRect * >(argp1);
7427 arg2 = obj1;
7428 {
7429 result = (bool)wxRect___eq__(arg1,arg2);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 PyObject *arg2 = (PyObject *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "other", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7458 }
7459 arg1 = reinterpret_cast< wxRect * >(argp1);
7460 arg2 = obj1;
7461 {
7462 result = (bool)wxRect___ne__(arg1,arg2);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 {
7466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7467 }
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj = 0;
7476 wxRect *arg1 = (wxRect *) 0 ;
7477 int arg2 ;
7478 int arg3 ;
7479 bool result;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 int val2 ;
7483 int ecode2 = 0 ;
7484 int val3 ;
7485 int ecode3 = 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 PyObject * obj2 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "x",(char *) "y", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7497 }
7498 arg1 = reinterpret_cast< wxRect * >(argp1);
7499 ecode2 = SWIG_AsVal_int(obj1, &val2);
7500 if (!SWIG_IsOK(ecode2)) {
7501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7502 }
7503 arg2 = static_cast< int >(val2);
7504 ecode3 = SWIG_AsVal_int(obj2, &val3);
7505 if (!SWIG_IsOK(ecode3)) {
7506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7507 }
7508 arg3 = static_cast< int >(val3);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj = 0;
7526 wxRect *arg1 = (wxRect *) 0 ;
7527 wxPoint *arg2 = 0 ;
7528 bool result;
7529 void *argp1 = 0 ;
7530 int res1 = 0 ;
7531 wxPoint temp2 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 char * kwnames[] = {
7535 (char *) "self",(char *) "pt", NULL
7536 };
7537
7538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7540 if (!SWIG_IsOK(res1)) {
7541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7542 }
7543 arg1 = reinterpret_cast< wxRect * >(argp1);
7544 {
7545 arg2 = &temp2;
7546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7547 }
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 {
7555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7556 }
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj = 0;
7565 wxRect *arg1 = (wxRect *) 0 ;
7566 wxRect *arg2 = 0 ;
7567 bool result;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 wxRect temp2 ;
7571 PyObject * obj0 = 0 ;
7572 PyObject * obj1 = 0 ;
7573 char * kwnames[] = {
7574 (char *) "self",(char *) "rect", NULL
7575 };
7576
7577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7579 if (!SWIG_IsOK(res1)) {
7580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7581 }
7582 arg1 = reinterpret_cast< wxRect * >(argp1);
7583 {
7584 arg2 = &temp2;
7585 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7586 }
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 wxRect *arg2 = 0 ;
7606 int arg3 = (int) wxBOTH ;
7607 wxRect result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 wxRect temp2 ;
7611 int val3 ;
7612 int ecode3 = 0 ;
7613 PyObject * obj0 = 0 ;
7614 PyObject * obj1 = 0 ;
7615 PyObject * obj2 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "r",(char *) "dir", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 if (obj2) {
7631 ecode3 = SWIG_AsVal_int(obj2, &val3);
7632 if (!SWIG_IsOK(ecode3)) {
7633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7634 }
7635 arg3 = static_cast< int >(val3);
7636 }
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7651 PyObject *resultobj = 0;
7652 wxRect *arg1 = (wxRect *) 0 ;
7653 int arg2 ;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 int val2 ;
7657 int ecode2 = 0 ;
7658 PyObject *swig_obj[2] ;
7659
7660 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7664 }
7665 arg1 = reinterpret_cast< wxRect * >(argp1);
7666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7667 if (!SWIG_IsOK(ecode2)) {
7668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7669 }
7670 arg2 = static_cast< int >(val2);
7671 if (arg1) (arg1)->x = arg2;
7672
7673 resultobj = SWIG_Py_Void();
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 int result;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 PyObject *swig_obj[1] ;
7687
7688 if (!args) SWIG_fail;
7689 swig_obj[0] = args;
7690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7693 }
7694 arg1 = reinterpret_cast< wxRect * >(argp1);
7695 result = (int) ((arg1)->x);
7696 resultobj = SWIG_From_int(static_cast< int >(result));
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 int arg2 ;
7707 void *argp1 = 0 ;
7708 int res1 = 0 ;
7709 int val2 ;
7710 int ecode2 = 0 ;
7711 PyObject *swig_obj[2] ;
7712
7713 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7717 }
7718 arg1 = reinterpret_cast< wxRect * >(argp1);
7719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7722 }
7723 arg2 = static_cast< int >(val2);
7724 if (arg1) (arg1)->y = arg2;
7725
7726 resultobj = SWIG_Py_Void();
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 PyObject *resultobj = 0;
7735 wxRect *arg1 = (wxRect *) 0 ;
7736 int result;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 PyObject *swig_obj[1] ;
7740
7741 if (!args) SWIG_fail;
7742 swig_obj[0] = args;
7743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7744 if (!SWIG_IsOK(res1)) {
7745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7746 }
7747 arg1 = reinterpret_cast< wxRect * >(argp1);
7748 result = (int) ((arg1)->y);
7749 resultobj = SWIG_From_int(static_cast< int >(result));
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7757 PyObject *resultobj = 0;
7758 wxRect *arg1 = (wxRect *) 0 ;
7759 int arg2 ;
7760 void *argp1 = 0 ;
7761 int res1 = 0 ;
7762 int val2 ;
7763 int ecode2 = 0 ;
7764 PyObject *swig_obj[2] ;
7765
7766 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7773 if (!SWIG_IsOK(ecode2)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7775 }
7776 arg2 = static_cast< int >(val2);
7777 if (arg1) (arg1)->width = arg2;
7778
7779 resultobj = SWIG_Py_Void();
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 PyObject *resultobj = 0;
7788 wxRect *arg1 = (wxRect *) 0 ;
7789 int result;
7790 void *argp1 = 0 ;
7791 int res1 = 0 ;
7792 PyObject *swig_obj[1] ;
7793
7794 if (!args) SWIG_fail;
7795 swig_obj[0] = args;
7796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7799 }
7800 arg1 = reinterpret_cast< wxRect * >(argp1);
7801 result = (int) ((arg1)->width);
7802 resultobj = SWIG_From_int(static_cast< int >(result));
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *resultobj = 0;
7811 wxRect *arg1 = (wxRect *) 0 ;
7812 int arg2 ;
7813 void *argp1 = 0 ;
7814 int res1 = 0 ;
7815 int val2 ;
7816 int ecode2 = 0 ;
7817 PyObject *swig_obj[2] ;
7818
7819 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7826 if (!SWIG_IsOK(ecode2)) {
7827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7828 }
7829 arg2 = static_cast< int >(val2);
7830 if (arg1) (arg1)->height = arg2;
7831
7832 resultobj = SWIG_Py_Void();
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7840 PyObject *resultobj = 0;
7841 wxRect *arg1 = (wxRect *) 0 ;
7842 int result;
7843 void *argp1 = 0 ;
7844 int res1 = 0 ;
7845 PyObject *swig_obj[1] ;
7846
7847 if (!args) SWIG_fail;
7848 swig_obj[0] = args;
7849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7852 }
7853 arg1 = reinterpret_cast< wxRect * >(argp1);
7854 result = (int) ((arg1)->height);
7855 resultobj = SWIG_From_int(static_cast< int >(result));
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 = (int) 0 ;
7866 int arg3 = (int) 0 ;
7867 int arg4 = (int) 0 ;
7868 int arg5 = (int) 0 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 int val2 ;
7872 int ecode2 = 0 ;
7873 int val3 ;
7874 int ecode3 = 0 ;
7875 int val4 ;
7876 int ecode4 = 0 ;
7877 int val5 ;
7878 int ecode5 = 0 ;
7879 PyObject * obj0 = 0 ;
7880 PyObject * obj1 = 0 ;
7881 PyObject * obj2 = 0 ;
7882 PyObject * obj3 = 0 ;
7883 PyObject * obj4 = 0 ;
7884 char * kwnames[] = {
7885 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7886 };
7887
7888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7890 if (!SWIG_IsOK(res1)) {
7891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7892 }
7893 arg1 = reinterpret_cast< wxRect * >(argp1);
7894 if (obj1) {
7895 ecode2 = SWIG_AsVal_int(obj1, &val2);
7896 if (!SWIG_IsOK(ecode2)) {
7897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7898 }
7899 arg2 = static_cast< int >(val2);
7900 }
7901 if (obj2) {
7902 ecode3 = SWIG_AsVal_int(obj2, &val3);
7903 if (!SWIG_IsOK(ecode3)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7905 }
7906 arg3 = static_cast< int >(val3);
7907 }
7908 if (obj3) {
7909 ecode4 = SWIG_AsVal_int(obj3, &val4);
7910 if (!SWIG_IsOK(ecode4)) {
7911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7912 }
7913 arg4 = static_cast< int >(val4);
7914 }
7915 if (obj4) {
7916 ecode5 = SWIG_AsVal_int(obj4, &val5);
7917 if (!SWIG_IsOK(ecode5)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7919 }
7920 arg5 = static_cast< int >(val5);
7921 }
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 resultobj = SWIG_Py_Void();
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *resultobj = 0;
7937 wxRect *arg1 = (wxRect *) 0 ;
7938 PyObject *result = 0 ;
7939 void *argp1 = 0 ;
7940 int res1 = 0 ;
7941 PyObject *swig_obj[1] ;
7942
7943 if (!args) SWIG_fail;
7944 swig_obj[0] = args;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (PyObject *)wxRect_Get(arg1);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = result;
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *obj;
7965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7966 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7967 return SWIG_Py_Void();
7968 }
7969
7970 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 return SWIG_Python_InitShadowInstance(args);
7972 }
7973
7974 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxRect *arg1 = (wxRect *) 0 ;
7977 wxRect *arg2 = (wxRect *) 0 ;
7978 PyObject *result = 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 void *argp2 = 0 ;
7982 int res2 = 0 ;
7983 PyObject * obj0 = 0 ;
7984 PyObject * obj1 = 0 ;
7985 char * kwnames[] = {
7986 (char *) "r1",(char *) "r2", NULL
7987 };
7988
7989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7991 if (!SWIG_IsOK(res1)) {
7992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7993 }
7994 arg1 = reinterpret_cast< wxRect * >(argp1);
7995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7996 if (!SWIG_IsOK(res2)) {
7997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7998 }
7999 arg2 = reinterpret_cast< wxRect * >(argp2);
8000 {
8001 if (!wxPyCheckForApp()) SWIG_fail;
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 result = (PyObject *)wxIntersectRect(arg1,arg2);
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 resultobj = result;
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj = 0;
8016 double arg1 = (double) 0.0 ;
8017 double arg2 = (double) 0.0 ;
8018 wxPoint2D *result = 0 ;
8019 double val1 ;
8020 int ecode1 = 0 ;
8021 double val2 ;
8022 int ecode2 = 0 ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char * kwnames[] = {
8026 (char *) "x",(char *) "y", NULL
8027 };
8028
8029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8030 if (obj0) {
8031 ecode1 = SWIG_AsVal_double(obj0, &val1);
8032 if (!SWIG_IsOK(ecode1)) {
8033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8034 }
8035 arg1 = static_cast< double >(val1);
8036 }
8037 if (obj1) {
8038 ecode2 = SWIG_AsVal_double(obj1, &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8041 }
8042 arg2 = static_cast< double >(val2);
8043 }
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 wxPoint2D *arg1 = 0 ;
8060 wxPoint2D *result = 0 ;
8061 wxPoint2D temp1 ;
8062 PyObject * obj0 = 0 ;
8063 char * kwnames[] = {
8064 (char *) "pt", NULL
8065 };
8066
8067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8068 {
8069 arg1 = &temp1;
8070 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8071 }
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj = 0;
8087 wxPoint *arg1 = 0 ;
8088 wxPoint2D *result = 0 ;
8089 wxPoint temp1 ;
8090 PyObject * obj0 = 0 ;
8091 char * kwnames[] = {
8092 (char *) "pt", NULL
8093 };
8094
8095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8096 {
8097 arg1 = &temp1;
8098 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8114 PyObject *resultobj = 0;
8115 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8116 int *arg2 = (int *) 0 ;
8117 int *arg3 = (int *) 0 ;
8118 void *argp1 = 0 ;
8119 int res1 = 0 ;
8120 int temp2 ;
8121 int res2 = SWIG_TMPOBJ ;
8122 int temp3 ;
8123 int res3 = SWIG_TMPOBJ ;
8124 PyObject *swig_obj[1] ;
8125
8126 arg2 = &temp2;
8127 arg3 = &temp3;
8128 if (!args) SWIG_fail;
8129 swig_obj[0] = args;
8130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8131 if (!SWIG_IsOK(res1)) {
8132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8133 }
8134 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 if (SWIG_IsTmpObj(res2)) {
8143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8144 } else {
8145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8147 }
8148 if (SWIG_IsTmpObj(res3)) {
8149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8150 } else {
8151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8153 }
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8161 PyObject *resultobj = 0;
8162 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8163 int *arg2 = (int *) 0 ;
8164 int *arg3 = (int *) 0 ;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 int temp2 ;
8168 int res2 = SWIG_TMPOBJ ;
8169 int temp3 ;
8170 int res3 = SWIG_TMPOBJ ;
8171 PyObject *swig_obj[1] ;
8172
8173 arg2 = &temp2;
8174 arg3 = &temp3;
8175 if (!args) SWIG_fail;
8176 swig_obj[0] = args;
8177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_Py_Void();
8189 if (SWIG_IsTmpObj(res2)) {
8190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8191 } else {
8192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8194 }
8195 if (SWIG_IsTmpObj(res3)) {
8196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8197 } else {
8198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8210 double result;
8211 void *argp1 = 0 ;
8212 int res1 = 0 ;
8213 PyObject *swig_obj[1] ;
8214
8215 if (!args) SWIG_fail;
8216 swig_obj[0] = args;
8217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_From_double(static_cast< double >(result));
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8236 PyObject *resultobj = 0;
8237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8238 double result;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 PyObject *swig_obj[1] ;
8242
8243 if (!args) SWIG_fail;
8244 swig_obj[0] = args;
8245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8248 }
8249 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_From_double(static_cast< double >(result));
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8266 double arg2 ;
8267 void *argp1 = 0 ;
8268 int res1 = 0 ;
8269 double val2 ;
8270 int ecode2 = 0 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "length", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8281 }
8282 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8283 ecode2 = SWIG_AsVal_double(obj1, &val2);
8284 if (!SWIG_IsOK(ecode2)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8286 }
8287 arg2 = static_cast< double >(val2);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 (arg1)->SetVectorLength(arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = SWIG_Py_Void();
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8304 double arg2 ;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 double val2 ;
8308 int ecode2 = 0 ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 char * kwnames[] = {
8312 (char *) "self",(char *) "degrees", NULL
8313 };
8314
8315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8317 if (!SWIG_IsOK(res1)) {
8318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8319 }
8320 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 (arg1)->SetVectorAngle(arg2);
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_Py_Void();
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 wxPoint2D *arg2 = 0 ;
8343 double result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 wxPoint2D temp2 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char * kwnames[] = {
8350 (char *) "self",(char *) "pt", NULL
8351 };
8352
8353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8357 }
8358 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8359 {
8360 arg2 = &temp2;
8361 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8362 }
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_From_double(static_cast< double >(result));
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 double result;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_From_double(static_cast< double >(result));
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 wxPoint2D *arg2 = 0 ;
8417 double result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxPoint2D temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "self",(char *) "vec", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8431 }
8432 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_From_double(static_cast< double >(result));
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj = 0;
8452 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8453 wxPoint2D *arg2 = 0 ;
8454 double result;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 wxPoint2D temp2 ;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 char * kwnames[] = {
8461 (char *) "self",(char *) "vec", NULL
8462 };
8463
8464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8468 }
8469 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8470 {
8471 arg2 = &temp2;
8472 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8473 }
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_From_double(static_cast< double >(result));
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 wxPoint2D result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->operator -();
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj = 0;
8517 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8518 wxPoint2D *arg2 = 0 ;
8519 wxPoint2D *result = 0 ;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 wxPoint2D temp2 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 char * kwnames[] = {
8526 (char *) "self",(char *) "pt", NULL
8527 };
8528
8529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8531 if (!SWIG_IsOK(res1)) {
8532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8533 }
8534 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8535 {
8536 arg2 = &temp2;
8537 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8538 }
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 {
8542 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8543 result = (wxPoint2D *) &_result_ref;
8544 }
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 wxPoint2D *result = 0 ;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 {
8582 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8583 result = (wxPoint2D *) &_result_ref;
8584 }
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj = 0;
8597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8598 wxPoint2D *arg2 = 0 ;
8599 wxPoint2D *result = 0 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 wxPoint2D temp2 ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char * kwnames[] = {
8606 (char *) "self",(char *) "pt", NULL
8607 };
8608
8609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8613 }
8614 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8615 {
8616 arg2 = &temp2;
8617 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 {
8622 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8623 result = (wxPoint2D *) &_result_ref;
8624 }
8625 wxPyEndAllowThreads(__tstate);
8626 if (PyErr_Occurred()) SWIG_fail;
8627 }
8628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj = 0;
8637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8638 wxPoint2D *arg2 = 0 ;
8639 wxPoint2D *result = 0 ;
8640 void *argp1 = 0 ;
8641 int res1 = 0 ;
8642 wxPoint2D temp2 ;
8643 PyObject * obj0 = 0 ;
8644 PyObject * obj1 = 0 ;
8645 char * kwnames[] = {
8646 (char *) "self",(char *) "pt", NULL
8647 };
8648
8649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8651 if (!SWIG_IsOK(res1)) {
8652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8653 }
8654 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8655 {
8656 arg2 = &temp2;
8657 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 {
8662 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8663 result = (wxPoint2D *) &_result_ref;
8664 }
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8669 return resultobj;
8670 fail:
8671 return NULL;
8672 }
8673
8674
8675 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8676 PyObject *resultobj = 0;
8677 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8678 PyObject *arg2 = (PyObject *) 0 ;
8679 bool result;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 PyObject * obj0 = 0 ;
8683 PyObject * obj1 = 0 ;
8684 char * kwnames[] = {
8685 (char *) "self",(char *) "other", NULL
8686 };
8687
8688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 arg2 = obj1;
8695 {
8696 result = (bool)wxPoint2D___eq__(arg1,arg2);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 {
8700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8701 }
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 PyObject *arg2 = (PyObject *) 0 ;
8712 bool result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 PyObject * obj0 = 0 ;
8716 PyObject * obj1 = 0 ;
8717 char * kwnames[] = {
8718 (char *) "self",(char *) "other", NULL
8719 };
8720
8721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8725 }
8726 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8727 arg2 = obj1;
8728 {
8729 result = (bool)wxPoint2D___ne__(arg1,arg2);
8730 if (PyErr_Occurred()) SWIG_fail;
8731 }
8732 {
8733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8734 }
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8742 PyObject *resultobj = 0;
8743 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8744 double arg2 ;
8745 void *argp1 = 0 ;
8746 int res1 = 0 ;
8747 double val2 ;
8748 int ecode2 = 0 ;
8749 PyObject *swig_obj[2] ;
8750
8751 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8753 if (!SWIG_IsOK(res1)) {
8754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8755 }
8756 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8757 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8758 if (!SWIG_IsOK(ecode2)) {
8759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8760 }
8761 arg2 = static_cast< double >(val2);
8762 if (arg1) (arg1)->m_x = arg2;
8763
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 double result;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 result = (double) ((arg1)->m_x);
8787 resultobj = SWIG_From_double(static_cast< double >(result));
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8795 PyObject *resultobj = 0;
8796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8797 double arg2 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 double val2 ;
8801 int ecode2 = 0 ;
8802 PyObject *swig_obj[2] ;
8803
8804 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8808 }
8809 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8810 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8811 if (!SWIG_IsOK(ecode2)) {
8812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8813 }
8814 arg2 = static_cast< double >(val2);
8815 if (arg1) (arg1)->m_y = arg2;
8816
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8825 PyObject *resultobj = 0;
8826 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8827 double result;
8828 void *argp1 = 0 ;
8829 int res1 = 0 ;
8830 PyObject *swig_obj[1] ;
8831
8832 if (!args) SWIG_fail;
8833 swig_obj[0] = args;
8834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8835 if (!SWIG_IsOK(res1)) {
8836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8837 }
8838 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8839 result = (double) ((arg1)->m_y);
8840 resultobj = SWIG_From_double(static_cast< double >(result));
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj = 0;
8849 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8850 double arg2 = (double) 0 ;
8851 double arg3 = (double) 0 ;
8852 void *argp1 = 0 ;
8853 int res1 = 0 ;
8854 double val2 ;
8855 int ecode2 = 0 ;
8856 double val3 ;
8857 int ecode3 = 0 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 PyObject * obj2 = 0 ;
8861 char * kwnames[] = {
8862 (char *) "self",(char *) "x",(char *) "y", NULL
8863 };
8864
8865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8867 if (!SWIG_IsOK(res1)) {
8868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8869 }
8870 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8871 if (obj1) {
8872 ecode2 = SWIG_AsVal_double(obj1, &val2);
8873 if (!SWIG_IsOK(ecode2)) {
8874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8875 }
8876 arg2 = static_cast< double >(val2);
8877 }
8878 if (obj2) {
8879 ecode3 = SWIG_AsVal_double(obj2, &val3);
8880 if (!SWIG_IsOK(ecode3)) {
8881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8882 }
8883 arg3 = static_cast< double >(val3);
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 wxPoint2D_Set(arg1,arg2,arg3);
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 resultobj = SWIG_Py_Void();
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8899 PyObject *resultobj = 0;
8900 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8901 PyObject *result = 0 ;
8902 void *argp1 = 0 ;
8903 int res1 = 0 ;
8904 PyObject *swig_obj[1] ;
8905
8906 if (!args) SWIG_fail;
8907 swig_obj[0] = args;
8908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8909 if (!SWIG_IsOK(res1)) {
8910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8911 }
8912 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (PyObject *)wxPoint2D_Get(arg1);
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = result;
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *obj;
8928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8929 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8930 return SWIG_Py_Void();
8931 }
8932
8933 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8934 return SWIG_Python_InitShadowInstance(args);
8935 }
8936
8937 SWIGINTERN int DefaultPosition_set(PyObject *) {
8938 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8939 return 1;
8940 }
8941
8942
8943 SWIGINTERN PyObject *DefaultPosition_get(void) {
8944 PyObject *pyobj = 0;
8945
8946 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8947 return pyobj;
8948 }
8949
8950
8951 SWIGINTERN int DefaultSize_set(PyObject *) {
8952 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8953 return 1;
8954 }
8955
8956
8957 SWIGINTERN PyObject *DefaultSize_get(void) {
8958 PyObject *pyobj = 0;
8959
8960 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8961 return pyobj;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = 0;
8967 PyObject *arg1 = (PyObject *) 0 ;
8968 wxPyInputStream *result = 0 ;
8969 PyObject * obj0 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "p", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8975 arg1 = obj0;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990 PyObject *resultobj = 0;
8991 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8992 void *argp1 = 0 ;
8993 int res1 = 0 ;
8994 PyObject *swig_obj[1] ;
8995
8996 if (!args) SWIG_fail;
8997 swig_obj[0] = args;
8998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9001 }
9002 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 delete arg1;
9006
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = SWIG_Py_Void();
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 PyObject *swig_obj[1] ;
9023
9024 if (!args) SWIG_fail;
9025 swig_obj[0] = args;
9026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9027 if (!SWIG_IsOK(res1)) {
9028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9029 }
9030 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 (arg1)->close();
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 resultobj = SWIG_Py_Void();
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 PyObject *swig_obj[1] ;
9050
9051 if (!args) SWIG_fail;
9052 swig_obj[0] = args;
9053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9054 if (!SWIG_IsOK(res1)) {
9055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9056 }
9057 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 (arg1)->flush();
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 resultobj = SWIG_Py_Void();
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9074 bool result;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 PyObject *swig_obj[1] ;
9078
9079 if (!args) SWIG_fail;
9080 swig_obj[0] = args;
9081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9084 }
9085 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (bool)(arg1)->eof();
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 {
9093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9094 }
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9104 int arg2 = (int) -1 ;
9105 PyObject *result = 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 int val2 ;
9109 int ecode2 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "self",(char *) "size", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9118 if (!SWIG_IsOK(res1)) {
9119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9120 }
9121 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9122 if (obj1) {
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 }
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (PyObject *)(arg1)->read(arg2);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = result;
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9145 int arg2 = (int) -1 ;
9146 PyObject *result = 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 int val2 ;
9150 int ecode2 = 0 ;
9151 PyObject * obj0 = 0 ;
9152 PyObject * obj1 = 0 ;
9153 char * kwnames[] = {
9154 (char *) "self",(char *) "size", NULL
9155 };
9156
9157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 if (obj1) {
9164 ecode2 = SWIG_AsVal_int(obj1, &val2);
9165 if (!SWIG_IsOK(ecode2)) {
9166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9167 }
9168 arg2 = static_cast< int >(val2);
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 result = (PyObject *)(arg1)->readline(arg2);
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 resultobj = result;
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj = 0;
9185 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9186 int arg2 = (int) -1 ;
9187 PyObject *result = 0 ;
9188 void *argp1 = 0 ;
9189 int res1 = 0 ;
9190 int val2 ;
9191 int ecode2 = 0 ;
9192 PyObject * obj0 = 0 ;
9193 PyObject * obj1 = 0 ;
9194 char * kwnames[] = {
9195 (char *) "self",(char *) "sizehint", NULL
9196 };
9197
9198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9202 }
9203 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9204 if (obj1) {
9205 ecode2 = SWIG_AsVal_int(obj1, &val2);
9206 if (!SWIG_IsOK(ecode2)) {
9207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9208 }
9209 arg2 = static_cast< int >(val2);
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (PyObject *)(arg1)->readlines(arg2);
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = result;
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = 0;
9226 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9227 int arg2 ;
9228 int arg3 = (int) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 int val2 ;
9232 int ecode2 = 0 ;
9233 int val3 ;
9234 int ecode3 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 PyObject * obj2 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "offset",(char *) "whence", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9246 }
9247 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 if (obj2) {
9254 ecode3 = SWIG_AsVal_int(obj2, &val3);
9255 if (!SWIG_IsOK(ecode3)) {
9256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9257 }
9258 arg3 = static_cast< int >(val3);
9259 }
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 (arg1)->seek(arg2,arg3);
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 resultobj = SWIG_Py_Void();
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9276 int result;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9286 }
9287 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (int)(arg1)->tell();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_From_int(static_cast< int >(result));
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9302 PyObject *resultobj = 0;
9303 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9304 char result;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9314 }
9315 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (char)(arg1)->Peek();
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_From_char(static_cast< char >(result));
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9332 char result;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 PyObject *swig_obj[1] ;
9336
9337 if (!args) SWIG_fail;
9338 swig_obj[0] = args;
9339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9342 }
9343 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (char)(arg1)->GetC();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_char(static_cast< char >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9360 size_t result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9370 }
9371 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (size_t)(arg1)->LastRead();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9386 PyObject *resultobj = 0;
9387 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9388 bool result;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 PyObject *swig_obj[1] ;
9392
9393 if (!args) SWIG_fail;
9394 swig_obj[0] = args;
9395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9396 if (!SWIG_IsOK(res1)) {
9397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9398 }
9399 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (bool)(arg1)->CanRead();
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9408 }
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 bool result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (bool)(arg1)->Eof();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9438 }
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9448 char arg2 ;
9449 bool result;
9450 void *argp1 = 0 ;
9451 int res1 = 0 ;
9452 char val2 ;
9453 int ecode2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "c", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9466 ecode2 = SWIG_AsVal_char(obj1, &val2);
9467 if (!SWIG_IsOK(ecode2)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9469 }
9470 arg2 = static_cast< char >(val2);
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (bool)(arg1)->Ungetch(arg2);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 {
9478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9479 }
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9487 PyObject *resultobj = 0;
9488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9489 long arg2 ;
9490 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9491 long result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 long val2 ;
9495 int ecode2 = 0 ;
9496 int val3 ;
9497 int ecode3 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 char * kwnames[] = {
9502 (char *) "self",(char *) "pos",(char *) "mode", NULL
9503 };
9504
9505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9507 if (!SWIG_IsOK(res1)) {
9508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9509 }
9510 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9511 ecode2 = SWIG_AsVal_long(obj1, &val2);
9512 if (!SWIG_IsOK(ecode2)) {
9513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9514 }
9515 arg2 = static_cast< long >(val2);
9516 if (obj2) {
9517 ecode3 = SWIG_AsVal_int(obj2, &val3);
9518 if (!SWIG_IsOK(ecode3)) {
9519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9520 }
9521 arg3 = static_cast< wxSeekMode >(val3);
9522 }
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (long)(arg1)->SeekI(arg2,arg3);
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_From_long(static_cast< long >(result));
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 PyObject *resultobj = 0;
9538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9539 long result;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 PyObject *swig_obj[1] ;
9543
9544 if (!args) SWIG_fail;
9545 swig_obj[0] = args;
9546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9547 if (!SWIG_IsOK(res1)) {
9548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9549 }
9550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (long)(arg1)->TellI();
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_From_long(static_cast< long >(result));
9558 return resultobj;
9559 fail:
9560 return NULL;
9561 }
9562
9563
9564 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9565 PyObject *obj;
9566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9567 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9568 return SWIG_Py_Void();
9569 }
9570
9571 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9572 return SWIG_Python_InitShadowInstance(args);
9573 }
9574
9575 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj = 0;
9577 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9578 PyObject *arg2 = (PyObject *) 0 ;
9579 void *argp1 = 0 ;
9580 int res1 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "obj", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9591 }
9592 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9593 arg2 = obj1;
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 wxOutputStream_write(arg1,arg2);
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_Py_Void();
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *resultobj = 0;
9609 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9610 size_t result;
9611 void *argp1 = 0 ;
9612 int res1 = 0 ;
9613 PyObject *swig_obj[1] ;
9614
9615 if (!args) SWIG_fail;
9616 swig_obj[0] = args;
9617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9620 }
9621 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9636 PyObject *obj;
9637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9638 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9639 return SWIG_Py_Void();
9640 }
9641
9642 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9643 PyObject *resultobj = 0;
9644 wxInputStream *arg1 = (wxInputStream *) 0 ;
9645 wxString *arg2 = 0 ;
9646 wxString *arg3 = 0 ;
9647 wxString *arg4 = 0 ;
9648 wxDateTime arg5 ;
9649 wxFSFile *result = 0 ;
9650 wxPyInputStream *temp1 ;
9651 bool temp2 = false ;
9652 bool temp3 = false ;
9653 bool temp4 = false ;
9654 void *argp5 ;
9655 int res5 = 0 ;
9656 PyObject * obj0 = 0 ;
9657 PyObject * obj1 = 0 ;
9658 PyObject * obj2 = 0 ;
9659 PyObject * obj3 = 0 ;
9660 PyObject * obj4 = 0 ;
9661 char * kwnames[] = {
9662 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9663 };
9664
9665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9666 {
9667 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9668 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9669 } else {
9670 PyErr_Clear(); // clear the failure of the wxPyConvert above
9671 arg1 = wxPyCBInputStream_create(obj0, true);
9672 if (arg1 == NULL) {
9673 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9674 SWIG_fail;
9675 }
9676 }
9677 }
9678 {
9679 arg2 = wxString_in_helper(obj1);
9680 if (arg2 == NULL) SWIG_fail;
9681 temp2 = true;
9682 }
9683 {
9684 arg3 = wxString_in_helper(obj2);
9685 if (arg3 == NULL) SWIG_fail;
9686 temp3 = true;
9687 }
9688 {
9689 arg4 = wxString_in_helper(obj3);
9690 if (arg4 == NULL) SWIG_fail;
9691 temp4 = true;
9692 }
9693 {
9694 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9695 if (!SWIG_IsOK(res5)) {
9696 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9697 }
9698 if (!argp5) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9700 } else {
9701 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9702 arg5 = *temp;
9703 if (SWIG_IsNewObj(res5)) delete temp;
9704 }
9705 }
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9713 {
9714 if (temp2)
9715 delete arg2;
9716 }
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 {
9722 if (temp4)
9723 delete arg4;
9724 }
9725 return resultobj;
9726 fail:
9727 {
9728 if (temp2)
9729 delete arg2;
9730 }
9731 {
9732 if (temp3)
9733 delete arg3;
9734 }
9735 {
9736 if (temp4)
9737 delete arg4;
9738 }
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxFSFile *arg1 = (wxFSFile *) 0 ;
9746 void *argp1 = 0 ;
9747 int res1 = 0 ;
9748 PyObject *swig_obj[1] ;
9749
9750 if (!args) SWIG_fail;
9751 swig_obj[0] = args;
9752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9753 if (!SWIG_IsOK(res1)) {
9754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9755 }
9756 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 delete arg1;
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_Py_Void();
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9772 PyObject *resultobj = 0;
9773 wxFSFile *arg1 = (wxFSFile *) 0 ;
9774 wxInputStream *result = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 PyObject *swig_obj[1] ;
9778
9779 if (!args) SWIG_fail;
9780 swig_obj[0] = args;
9781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9784 }
9785 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (wxInputStream *)(arg1)->GetStream();
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 {
9793 wxPyInputStream * _ptr = NULL;
9794
9795 if (result) {
9796 _ptr = new wxPyInputStream(result);
9797 }
9798 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 wxFSFile *arg1 = (wxFSFile *) 0 ;
9809 wxString *result = 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 PyObject *swig_obj[1] ;
9813
9814 if (!args) SWIG_fail;
9815 swig_obj[0] = args;
9816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9819 }
9820 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 {
9824 wxString const &_result_ref = (arg1)->GetMimeType();
9825 result = (wxString *) &_result_ref;
9826 }
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *resultobj = 0;
9845 wxFSFile *arg1 = (wxFSFile *) 0 ;
9846 wxString *result = 0 ;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 PyObject *swig_obj[1] ;
9850
9851 if (!args) SWIG_fail;
9852 swig_obj[0] = args;
9853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9856 }
9857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 {
9861 wxString const &_result_ref = (arg1)->GetLocation();
9862 result = (wxString *) &_result_ref;
9863 }
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 PyObject *resultobj = 0;
9882 wxFSFile *arg1 = (wxFSFile *) 0 ;
9883 wxString *result = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 PyObject *swig_obj[1] ;
9887
9888 if (!args) SWIG_fail;
9889 swig_obj[0] = args;
9890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9893 }
9894 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 {
9898 wxString const &_result_ref = (arg1)->GetAnchor();
9899 result = (wxString *) &_result_ref;
9900 }
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 #if wxUSE_UNICODE
9906 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9907 #else
9908 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9909 #endif
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxFSFile *arg1 = (wxFSFile *) 0 ;
9920 wxDateTime result;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9930 }
9931 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (arg1)->GetModificationTime();
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *obj;
9947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9948 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9949 return SWIG_Py_Void();
9950 }
9951
9952 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 return SWIG_Python_InitShadowInstance(args);
9954 }
9955
9956 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9957 PyObject *resultobj = 0;
9958 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject *swig_obj[1] ;
9962
9963 if (!args) SWIG_fail;
9964 swig_obj[0] = args;
9965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9968 }
9969 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 delete arg1;
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 resultobj = SWIG_Py_Void();
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *obj;
9986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9987 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9988 return SWIG_Py_Void();
9989 }
9990
9991 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9992 PyObject *resultobj = 0;
9993 wxPyFileSystemHandler *result = 0 ;
9994
9995 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10012 PyObject *arg2 = (PyObject *) 0 ;
10013 PyObject *arg3 = (PyObject *) 0 ;
10014 void *argp1 = 0 ;
10015 int res1 = 0 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 PyObject * obj2 = 0 ;
10019 char * kwnames[] = {
10020 (char *) "self",(char *) "self",(char *) "_class", NULL
10021 };
10022
10023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10029 arg2 = obj1;
10030 arg3 = obj2;
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 (arg1)->_setCallbackInfo(arg2,arg3);
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 resultobj = SWIG_Py_Void();
10038 return resultobj;
10039 fail:
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10047 wxString *arg2 = 0 ;
10048 bool result;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 bool temp2 = false ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "location", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10062 }
10063 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10064 {
10065 arg2 = wxString_in_helper(obj1);
10066 if (arg2 == NULL) SWIG_fail;
10067 temp2 = true;
10068 }
10069 {
10070 PyThreadState* __tstate = wxPyBeginAllowThreads();
10071 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 {
10076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10077 }
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10093 PyObject *resultobj = 0;
10094 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10095 wxFileSystem *arg2 = 0 ;
10096 wxString *arg3 = 0 ;
10097 wxFSFile *result = 0 ;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 void *argp2 = 0 ;
10101 int res2 = 0 ;
10102 bool temp3 = false ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 PyObject * obj2 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "fs",(char *) "location", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10117 if (!SWIG_IsOK(res2)) {
10118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10119 }
10120 if (!argp2) {
10121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10122 }
10123 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10124 {
10125 arg3 = wxString_in_helper(obj2);
10126 if (arg3 == NULL) SWIG_fail;
10127 temp3 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10137 }
10138 {
10139 if (temp3)
10140 delete arg3;
10141 }
10142 return resultobj;
10143 fail:
10144 {
10145 if (temp3)
10146 delete arg3;
10147 }
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj = 0;
10154 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 int arg3 = (int) 0 ;
10157 wxString result;
10158 void *argp1 = 0 ;
10159 int res1 = 0 ;
10160 bool temp2 = false ;
10161 int val3 ;
10162 int ecode3 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 PyObject * obj2 = 0 ;
10166 char * kwnames[] = {
10167 (char *) "self",(char *) "spec",(char *) "flags", NULL
10168 };
10169
10170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10174 }
10175 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10176 {
10177 arg2 = wxString_in_helper(obj1);
10178 if (arg2 == NULL) SWIG_fail;
10179 temp2 = true;
10180 }
10181 if (obj2) {
10182 ecode3 = SWIG_AsVal_int(obj2, &val3);
10183 if (!SWIG_IsOK(ecode3)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10185 }
10186 arg3 = static_cast< int >(val3);
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 #if wxUSE_UNICODE
10196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10197 #else
10198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10199 #endif
10200 }
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10216 PyObject *resultobj = 0;
10217 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10218 wxString result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 PyObject *swig_obj[1] ;
10222
10223 if (!args) SWIG_fail;
10224 swig_obj[0] = args;
10225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10228 }
10229 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (arg1)->FindNext();
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 {
10237 #if wxUSE_UNICODE
10238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10239 #else
10240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10241 #endif
10242 }
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10252 wxString *arg2 = 0 ;
10253 wxString result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "location", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->GetProtocol((wxString const &)*arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString *arg2 = 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "location", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 #if wxUSE_UNICODE
10334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10335 #else
10336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10337 #endif
10338 }
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = 0;
10355 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10356 wxString *arg2 = 0 ;
10357 wxString result;
10358 void *argp1 = 0 ;
10359 int res1 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char * kwnames[] = {
10364 (char *) "self",(char *) "location", NULL
10365 };
10366
10367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (arg1)->GetAnchor((wxString const &)*arg2);
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 #if wxUSE_UNICODE
10386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10387 #else
10388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10389 #endif
10390 }
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10408 wxString *arg2 = 0 ;
10409 wxString result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 bool temp2 = false ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "location", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 {
10437 #if wxUSE_UNICODE
10438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10439 #else
10440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10441 #endif
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10458 PyObject *resultobj = 0;
10459 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10460 wxString *arg2 = 0 ;
10461 wxString result;
10462 void *argp1 = 0 ;
10463 int res1 = 0 ;
10464 bool temp2 = false ;
10465 PyObject * obj0 = 0 ;
10466 PyObject * obj1 = 0 ;
10467 char * kwnames[] = {
10468 (char *) "self",(char *) "location", NULL
10469 };
10470
10471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10473 if (!SWIG_IsOK(res1)) {
10474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10475 }
10476 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10477 {
10478 arg2 = wxString_in_helper(obj1);
10479 if (arg2 == NULL) SWIG_fail;
10480 temp2 = true;
10481 }
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 {
10489 #if wxUSE_UNICODE
10490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10491 #else
10492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10493 #endif
10494 }
10495 {
10496 if (temp2)
10497 delete arg2;
10498 }
10499 return resultobj;
10500 fail:
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10510 PyObject *obj;
10511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10512 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10513 return SWIG_Py_Void();
10514 }
10515
10516 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10517 return SWIG_Python_InitShadowInstance(args);
10518 }
10519
10520 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxFileSystem *result = 0 ;
10523
10524 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (wxFileSystem *)new wxFileSystem();
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10533 }
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10552 }
10553 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 delete arg1;
10557
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10569 PyObject *resultobj = 0;
10570 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10571 wxString *arg2 = 0 ;
10572 bool arg3 = (bool) false ;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 bool temp2 = false ;
10576 bool val3 ;
10577 int ecode3 = 0 ;
10578 PyObject * obj0 = 0 ;
10579 PyObject * obj1 = 0 ;
10580 PyObject * obj2 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10589 }
10590 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 if (obj2) {
10597 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10598 if (!SWIG_IsOK(ecode3)) {
10599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10600 }
10601 arg3 = static_cast< bool >(val3);
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_Py_Void();
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return resultobj;
10615 fail:
10616 {
10617 if (temp2)
10618 delete arg2;
10619 }
10620 return NULL;
10621 }
10622
10623
10624 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10625 PyObject *resultobj = 0;
10626 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 PyObject *swig_obj[1] ;
10631
10632 if (!args) SWIG_fail;
10633 swig_obj[0] = args;
10634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10637 }
10638 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (arg1)->GetPath();
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 {
10646 #if wxUSE_UNICODE
10647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10648 #else
10649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10650 #endif
10651 }
10652 return resultobj;
10653 fail:
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10659 PyObject *resultobj = 0;
10660 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10661 wxString *arg2 = 0 ;
10662 wxFSFile *result = 0 ;
10663 void *argp1 = 0 ;
10664 int res1 = 0 ;
10665 bool temp2 = false ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "location", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 {
10690 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10691 }
10692 {
10693 if (temp2)
10694 delete arg2;
10695 }
10696 return resultobj;
10697 fail:
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10707 PyObject *resultobj = 0;
10708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10709 wxString *arg2 = 0 ;
10710 int arg3 = (int) 0 ;
10711 wxString result;
10712 void *argp1 = 0 ;
10713 int res1 = 0 ;
10714 bool temp2 = false ;
10715 int val3 ;
10716 int ecode3 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "spec",(char *) "flags", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10728 }
10729 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10730 {
10731 arg2 = wxString_in_helper(obj1);
10732 if (arg2 == NULL) SWIG_fail;
10733 temp2 = true;
10734 }
10735 if (obj2) {
10736 ecode3 = SWIG_AsVal_int(obj2, &val3);
10737 if (!SWIG_IsOK(ecode3)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10739 }
10740 arg3 = static_cast< int >(val3);
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 #if wxUSE_UNICODE
10750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10751 #else
10752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10753 #endif
10754 }
10755 {
10756 if (temp2)
10757 delete arg2;
10758 }
10759 return resultobj;
10760 fail:
10761 {
10762 if (temp2)
10763 delete arg2;
10764 }
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10770 PyObject *resultobj = 0;
10771 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10772 wxString result;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 PyObject *swig_obj[1] ;
10776
10777 if (!args) SWIG_fail;
10778 swig_obj[0] = args;
10779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10780 if (!SWIG_IsOK(res1)) {
10781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10782 }
10783 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (arg1)->FindNext();
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 #if wxUSE_UNICODE
10792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10793 #else
10794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10795 #endif
10796 }
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj = 0;
10805 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10806 int res1 = 0 ;
10807 PyObject * obj0 = 0 ;
10808 char * kwnames[] = {
10809 (char *) "handler", NULL
10810 };
10811
10812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10813 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10814 if (!SWIG_IsOK(res1)) {
10815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10816 }
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 wxFileSystem::AddHandler(arg1);
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_Py_Void();
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10831 PyObject *resultobj = 0;
10832
10833 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 wxFileSystem::CleanUpHandlers();
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxString *arg1 = 0 ;
10850 wxString result;
10851 bool temp1 = false ;
10852 PyObject * obj0 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "filename", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10858 {
10859 arg1 = wxString_in_helper(obj0);
10860 if (arg1 == NULL) SWIG_fail;
10861 temp1 = true;
10862 }
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 #if wxUSE_UNICODE
10871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10872 #else
10873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10874 #endif
10875 }
10876 {
10877 if (temp1)
10878 delete arg1;
10879 }
10880 return resultobj;
10881 fail:
10882 {
10883 if (temp1)
10884 delete arg1;
10885 }
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxString *arg1 = 0 ;
10893 wxString result;
10894 bool temp1 = false ;
10895 PyObject * obj0 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "url", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10901 {
10902 arg1 = wxString_in_helper(obj0);
10903 if (arg1 == NULL) SWIG_fail;
10904 temp1 = true;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 #if wxUSE_UNICODE
10914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10915 #else
10916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10917 #endif
10918 }
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934 PyObject *obj;
10935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10936 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10937 return SWIG_Py_Void();
10938 }
10939
10940 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10941 return SWIG_Python_InitShadowInstance(args);
10942 }
10943
10944 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 PyObject *resultobj = 0;
10946 wxInternetFSHandler *result = 0 ;
10947
10948 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10965 wxString *arg2 = 0 ;
10966 bool result;
10967 void *argp1 = 0 ;
10968 int res1 = 0 ;
10969 bool temp2 = false ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "location", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10980 }
10981 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10982 {
10983 arg2 = wxString_in_helper(obj1);
10984 if (arg2 == NULL) SWIG_fail;
10985 temp2 = true;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10990 wxPyEndAllowThreads(__tstate);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 {
10997 if (temp2)
10998 delete arg2;
10999 }
11000 return resultobj;
11001 fail:
11002 {
11003 if (temp2)
11004 delete arg2;
11005 }
11006 return NULL;
11007 }
11008
11009
11010 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj = 0;
11012 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11013 wxFileSystem *arg2 = 0 ;
11014 wxString *arg3 = 0 ;
11015 wxFSFile *result = 0 ;
11016 void *argp1 = 0 ;
11017 int res1 = 0 ;
11018 void *argp2 = 0 ;
11019 int res2 = 0 ;
11020 bool temp3 = false ;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 char * kwnames[] = {
11025 (char *) "self",(char *) "fs",(char *) "location", NULL
11026 };
11027
11028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11032 }
11033 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11040 }
11041 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11042 {
11043 arg3 = wxString_in_helper(obj2);
11044 if (arg3 == NULL) SWIG_fail;
11045 temp3 = true;
11046 }
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11055 }
11056 {
11057 if (temp3)
11058 delete arg3;
11059 }
11060 return resultobj;
11061 fail:
11062 {
11063 if (temp3)
11064 delete arg3;
11065 }
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11071 PyObject *obj;
11072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11073 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11074 return SWIG_Py_Void();
11075 }
11076
11077 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 return SWIG_Python_InitShadowInstance(args);
11079 }
11080
11081 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11082 PyObject *resultobj = 0;
11083 wxZipFSHandler *result = 0 ;
11084
11085 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (wxZipFSHandler *)new wxZipFSHandler();
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11102 wxString *arg2 = 0 ;
11103 bool result;
11104 void *argp1 = 0 ;
11105 int res1 = 0 ;
11106 bool temp2 = false ;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 char * kwnames[] = {
11110 (char *) "self",(char *) "location", NULL
11111 };
11112
11113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 {
11120 arg2 = wxString_in_helper(obj1);
11121 if (arg2 == NULL) SWIG_fail;
11122 temp2 = true;
11123 }
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 {
11131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11132 }
11133 {
11134 if (temp2)
11135 delete arg2;
11136 }
11137 return resultobj;
11138 fail:
11139 {
11140 if (temp2)
11141 delete arg2;
11142 }
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj = 0;
11149 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11150 wxFileSystem *arg2 = 0 ;
11151 wxString *arg3 = 0 ;
11152 wxFSFile *result = 0 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 void *argp2 = 0 ;
11156 int res2 = 0 ;
11157 bool temp3 = false ;
11158 PyObject * obj0 = 0 ;
11159 PyObject * obj1 = 0 ;
11160 PyObject * obj2 = 0 ;
11161 char * kwnames[] = {
11162 (char *) "self",(char *) "fs",(char *) "location", NULL
11163 };
11164
11165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11167 if (!SWIG_IsOK(res1)) {
11168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11169 }
11170 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11172 if (!SWIG_IsOK(res2)) {
11173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11174 }
11175 if (!argp2) {
11176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11177 }
11178 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11179 {
11180 arg3 = wxString_in_helper(obj2);
11181 if (arg3 == NULL) SWIG_fail;
11182 temp3 = true;
11183 }
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11192 }
11193 {
11194 if (temp3)
11195 delete arg3;
11196 }
11197 return resultobj;
11198 fail:
11199 {
11200 if (temp3)
11201 delete arg3;
11202 }
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj = 0;
11209 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11210 wxString *arg2 = 0 ;
11211 int arg3 = (int) 0 ;
11212 wxString result;
11213 void *argp1 = 0 ;
11214 int res1 = 0 ;
11215 bool temp2 = false ;
11216 int val3 ;
11217 int ecode3 = 0 ;
11218 PyObject * obj0 = 0 ;
11219 PyObject * obj1 = 0 ;
11220 PyObject * obj2 = 0 ;
11221 char * kwnames[] = {
11222 (char *) "self",(char *) "spec",(char *) "flags", NULL
11223 };
11224
11225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11227 if (!SWIG_IsOK(res1)) {
11228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11229 }
11230 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11231 {
11232 arg2 = wxString_in_helper(obj1);
11233 if (arg2 == NULL) SWIG_fail;
11234 temp2 = true;
11235 }
11236 if (obj2) {
11237 ecode3 = SWIG_AsVal_int(obj2, &val3);
11238 if (!SWIG_IsOK(ecode3)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11240 }
11241 arg3 = static_cast< int >(val3);
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 #if wxUSE_UNICODE
11251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11252 #else
11253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11254 #endif
11255 }
11256 {
11257 if (temp2)
11258 delete arg2;
11259 }
11260 return resultobj;
11261 fail:
11262 {
11263 if (temp2)
11264 delete arg2;
11265 }
11266 return NULL;
11267 }
11268
11269
11270 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11271 PyObject *resultobj = 0;
11272 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11273 wxString result;
11274 void *argp1 = 0 ;
11275 int res1 = 0 ;
11276 PyObject *swig_obj[1] ;
11277
11278 if (!args) SWIG_fail;
11279 swig_obj[0] = args;
11280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11281 if (!SWIG_IsOK(res1)) {
11282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11283 }
11284 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (arg1)->FindNext();
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 #if wxUSE_UNICODE
11293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11294 #else
11295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11296 #endif
11297 }
11298 return resultobj;
11299 fail:
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 PyObject *obj;
11306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11307 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11308 return SWIG_Py_Void();
11309 }
11310
11311 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11312 return SWIG_Python_InitShadowInstance(args);
11313 }
11314
11315 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj = 0;
11317 wxString *arg1 = 0 ;
11318 wxImage *arg2 = 0 ;
11319 long arg3 ;
11320 bool temp1 = false ;
11321 void *argp2 = 0 ;
11322 int res2 = 0 ;
11323 long val3 ;
11324 int ecode3 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "filename",(char *) "image",(char *) "type", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 {
11334 arg1 = wxString_in_helper(obj0);
11335 if (arg1 == NULL) SWIG_fail;
11336 temp1 = true;
11337 }
11338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11341 }
11342 if (!argp2) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11344 }
11345 arg2 = reinterpret_cast< wxImage * >(argp2);
11346 ecode3 = SWIG_AsVal_long(obj2, &val3);
11347 if (!SWIG_IsOK(ecode3)) {
11348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11349 }
11350 arg3 = static_cast< long >(val3);
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxString *arg1 = 0 ;
11375 wxBitmap *arg2 = 0 ;
11376 long arg3 ;
11377 bool temp1 = false ;
11378 void *argp2 = 0 ;
11379 int res2 = 0 ;
11380 long val3 ;
11381 int ecode3 = 0 ;
11382 PyObject * obj0 = 0 ;
11383 PyObject * obj1 = 0 ;
11384 PyObject * obj2 = 0 ;
11385 char * kwnames[] = {
11386 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11387 };
11388
11389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11390 {
11391 arg1 = wxString_in_helper(obj0);
11392 if (arg1 == NULL) SWIG_fail;
11393 temp1 = true;
11394 }
11395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11396 if (!SWIG_IsOK(res2)) {
11397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11398 }
11399 if (!argp2) {
11400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11401 }
11402 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11403 ecode3 = SWIG_AsVal_long(obj2, &val3);
11404 if (!SWIG_IsOK(ecode3)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11406 }
11407 arg3 = static_cast< long >(val3);
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 resultobj = SWIG_Py_Void();
11415 {
11416 if (temp1)
11417 delete arg1;
11418 }
11419 return resultobj;
11420 fail:
11421 {
11422 if (temp1)
11423 delete arg1;
11424 }
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 PyObject *arg2 = (PyObject *) 0 ;
11433 bool temp1 = false ;
11434 PyObject * obj0 = 0 ;
11435 PyObject * obj1 = 0 ;
11436 char * kwnames[] = {
11437 (char *) "filename",(char *) "data", NULL
11438 };
11439
11440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11441 {
11442 arg1 = wxString_in_helper(obj0);
11443 if (arg1 == NULL) SWIG_fail;
11444 temp1 = true;
11445 }
11446 arg2 = obj1;
11447 {
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 resultobj = SWIG_Py_Void();
11454 {
11455 if (temp1)
11456 delete arg1;
11457 }
11458 return resultobj;
11459 fail:
11460 {
11461 if (temp1)
11462 delete arg1;
11463 }
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 wxMemoryFSHandler *result = 0 ;
11471
11472 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj = 0;
11488 wxString *arg1 = 0 ;
11489 bool temp1 = false ;
11490 PyObject * obj0 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "filename", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11496 {
11497 arg1 = wxString_in_helper(obj0);
11498 if (arg1 == NULL) SWIG_fail;
11499 temp1 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 resultobj = SWIG_Py_Void();
11508 {
11509 if (temp1)
11510 delete arg1;
11511 }
11512 return resultobj;
11513 fail:
11514 {
11515 if (temp1)
11516 delete arg1;
11517 }
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11525 wxString *arg2 = 0 ;
11526 bool result;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 bool temp2 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 char * kwnames[] = {
11533 (char *) "self",(char *) "location", NULL
11534 };
11535
11536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 {
11543 arg2 = wxString_in_helper(obj1);
11544 if (arg2 == NULL) SWIG_fail;
11545 temp2 = true;
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 {
11557 if (temp2)
11558 delete arg2;
11559 }
11560 return resultobj;
11561 fail:
11562 {
11563 if (temp2)
11564 delete arg2;
11565 }
11566 return NULL;
11567 }
11568
11569
11570 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11571 PyObject *resultobj = 0;
11572 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11573 wxFileSystem *arg2 = 0 ;
11574 wxString *arg3 = 0 ;
11575 wxFSFile *result = 0 ;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 void *argp2 = 0 ;
11579 int res2 = 0 ;
11580 bool temp3 = false ;
11581 PyObject * obj0 = 0 ;
11582 PyObject * obj1 = 0 ;
11583 PyObject * obj2 = 0 ;
11584 char * kwnames[] = {
11585 (char *) "self",(char *) "fs",(char *) "location", NULL
11586 };
11587
11588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11592 }
11593 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11595 if (!SWIG_IsOK(res2)) {
11596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11597 }
11598 if (!argp2) {
11599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11600 }
11601 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11602 {
11603 arg3 = wxString_in_helper(obj2);
11604 if (arg3 == NULL) SWIG_fail;
11605 temp3 = true;
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11615 }
11616 {
11617 if (temp3)
11618 delete arg3;
11619 }
11620 return resultobj;
11621 fail:
11622 {
11623 if (temp3)
11624 delete arg3;
11625 }
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj = 0;
11632 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11633 wxString *arg2 = 0 ;
11634 int arg3 = (int) 0 ;
11635 wxString result;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 bool temp2 = false ;
11639 int val3 ;
11640 int ecode3 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 PyObject * obj2 = 0 ;
11644 char * kwnames[] = {
11645 (char *) "self",(char *) "spec",(char *) "flags", NULL
11646 };
11647
11648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11652 }
11653 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11654 {
11655 arg2 = wxString_in_helper(obj1);
11656 if (arg2 == NULL) SWIG_fail;
11657 temp2 = true;
11658 }
11659 if (obj2) {
11660 ecode3 = SWIG_AsVal_int(obj2, &val3);
11661 if (!SWIG_IsOK(ecode3)) {
11662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11663 }
11664 arg3 = static_cast< int >(val3);
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 #if wxUSE_UNICODE
11674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11675 #else
11676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11677 #endif
11678 }
11679 {
11680 if (temp2)
11681 delete arg2;
11682 }
11683 return resultobj;
11684 fail:
11685 {
11686 if (temp2)
11687 delete arg2;
11688 }
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11696 wxString result;
11697 void *argp1 = 0 ;
11698 int res1 = 0 ;
11699 PyObject *swig_obj[1] ;
11700
11701 if (!args) SWIG_fail;
11702 swig_obj[0] = args;
11703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11706 }
11707 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (arg1)->FindNext();
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 #if wxUSE_UNICODE
11716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11717 #else
11718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11719 #endif
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11728 PyObject *obj;
11729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11730 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11731 return SWIG_Py_Void();
11732 }
11733
11734 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 return SWIG_Python_InitShadowInstance(args);
11736 }
11737
11738 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11741 wxString result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11751 }
11752 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (arg1)->GetName();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 #if wxUSE_UNICODE
11761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11762 #else
11763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11764 #endif
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11773 PyObject *resultobj = 0;
11774 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11775 wxString result;
11776 void *argp1 = 0 ;
11777 int res1 = 0 ;
11778 PyObject *swig_obj[1] ;
11779
11780 if (!args) SWIG_fail;
11781 swig_obj[0] = args;
11782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11783 if (!SWIG_IsOK(res1)) {
11784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11785 }
11786 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (arg1)->GetExtension();
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 {
11794 #if wxUSE_UNICODE
11795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11796 #else
11797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11798 #endif
11799 }
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11809 long result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11819 }
11820 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (long)(arg1)->GetType();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_long(static_cast< long >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11837 wxString result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11847 }
11848 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (arg1)->GetMimeType();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 #if wxUSE_UNICODE
11857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11858 #else
11859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11860 #endif
11861 }
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11871 wxString *arg2 = 0 ;
11872 bool result;
11873 void *argp1 = 0 ;
11874 int res1 = 0 ;
11875 bool temp2 = false ;
11876 PyObject * obj0 = 0 ;
11877 PyObject * obj1 = 0 ;
11878 char * kwnames[] = {
11879 (char *) "self",(char *) "name", NULL
11880 };
11881
11882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11886 }
11887 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11888 {
11889 arg2 = wxString_in_helper(obj1);
11890 if (arg2 == NULL) SWIG_fail;
11891 temp2 = true;
11892 }
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 {
11900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11901 }
11902 {
11903 if (temp2)
11904 delete arg2;
11905 }
11906 return resultobj;
11907 fail:
11908 {
11909 if (temp2)
11910 delete arg2;
11911 }
11912 return NULL;
11913 }
11914
11915
11916 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj = 0;
11918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11919 wxInputStream *arg2 = 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 wxPyInputStream *temp2 ;
11924 bool created2 ;
11925 PyObject * obj0 = 0 ;
11926 PyObject * obj1 = 0 ;
11927 char * kwnames[] = {
11928 (char *) "self",(char *) "stream", NULL
11929 };
11930
11931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11939 arg2 = temp2->m_wxis;
11940 created2 = false;
11941 } else {
11942 PyErr_Clear(); // clear the failure of the wxPyConvert above
11943 arg2 = wxPyCBInputStream_create(obj1, false);
11944 if (arg2 == NULL) {
11945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11946 SWIG_fail;
11947 }
11948 created2 = true;
11949 }
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead(*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (created2) delete arg2;
11962 }
11963 return resultobj;
11964 fail:
11965 {
11966 if (created2) delete arg2;
11967 }
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj = 0;
11974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11975 wxString *arg2 = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 bool temp2 = false ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 char * kwnames[] = {
11982 (char *) "self",(char *) "name", NULL
11983 };
11984
11985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11989 }
11990 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11991 {
11992 arg2 = wxString_in_helper(obj1);
11993 if (arg2 == NULL) SWIG_fail;
11994 temp2 = true;
11995 }
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 (arg1)->SetName((wxString const &)*arg2);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_Py_Void();
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12020 wxString *arg2 = 0 ;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 bool temp2 = false ;
12024 PyObject * obj0 = 0 ;
12025 PyObject * obj1 = 0 ;
12026 char * kwnames[] = {
12027 (char *) "self",(char *) "extension", NULL
12028 };
12029
12030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12032 if (!SWIG_IsOK(res1)) {
12033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12034 }
12035 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12036 {
12037 arg2 = wxString_in_helper(obj1);
12038 if (arg2 == NULL) SWIG_fail;
12039 temp2 = true;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 (arg1)->SetExtension((wxString const &)*arg2);
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 resultobj = SWIG_Py_Void();
12048 {
12049 if (temp2)
12050 delete arg2;
12051 }
12052 return resultobj;
12053 fail:
12054 {
12055 if (temp2)
12056 delete arg2;
12057 }
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12063 PyObject *resultobj = 0;
12064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12065 long arg2 ;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 long val2 ;
12069 int ecode2 = 0 ;
12070 PyObject * obj0 = 0 ;
12071 PyObject * obj1 = 0 ;
12072 char * kwnames[] = {
12073 (char *) "self",(char *) "type", NULL
12074 };
12075
12076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12080 }
12081 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12082 ecode2 = SWIG_AsVal_long(obj1, &val2);
12083 if (!SWIG_IsOK(ecode2)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12085 }
12086 arg2 = static_cast< long >(val2);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 (arg1)->SetType(arg2);
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_Py_Void();
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj = 0;
12102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12103 wxString *arg2 = 0 ;
12104 void *argp1 = 0 ;
12105 int res1 = 0 ;
12106 bool temp2 = false ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 char * kwnames[] = {
12110 (char *) "self",(char *) "mimetype", NULL
12111 };
12112
12113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12117 }
12118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12119 {
12120 arg2 = wxString_in_helper(obj1);
12121 if (arg2 == NULL) SWIG_fail;
12122 temp2 = true;
12123 }
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 (arg1)->SetMimeType((wxString const &)*arg2);
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 resultobj = SWIG_Py_Void();
12131 {
12132 if (temp2)
12133 delete arg2;
12134 }
12135 return resultobj;
12136 fail:
12137 {
12138 if (temp2)
12139 delete arg2;
12140 }
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *obj;
12147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12148 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12149 return SWIG_Py_Void();
12150 }
12151
12152 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *resultobj = 0;
12154 wxPyImageHandler *result = 0 ;
12155
12156 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (wxPyImageHandler *)new wxPyImageHandler();
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj = 0;
12172 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12173 PyObject *arg2 = (PyObject *) 0 ;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "self", NULL
12180 };
12181
12182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12186 }
12187 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12188 arg2 = obj1;
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 (arg1)->_SetSelf(arg2);
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_Py_Void();
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *obj;
12204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12205 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12206 return SWIG_Py_Void();
12207 }
12208
12209 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 return SWIG_Python_InitShadowInstance(args);
12211 }
12212
12213 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12214 PyObject *resultobj = 0;
12215 wxImageHistogram *result = 0 ;
12216
12217 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (wxImageHistogram *)new wxImageHistogram();
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 byte arg1 ;
12234 byte arg2 ;
12235 byte arg3 ;
12236 unsigned long result;
12237 unsigned char val1 ;
12238 int ecode1 = 0 ;
12239 unsigned char val2 ;
12240 int ecode2 = 0 ;
12241 unsigned char val3 ;
12242 int ecode3 = 0 ;
12243 PyObject * obj0 = 0 ;
12244 PyObject * obj1 = 0 ;
12245 PyObject * obj2 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "r",(char *) "g",(char *) "b", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12251 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12252 if (!SWIG_IsOK(ecode1)) {
12253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12254 }
12255 arg1 = static_cast< byte >(val1);
12256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12257 if (!SWIG_IsOK(ecode2)) {
12258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12259 }
12260 arg2 = static_cast< byte >(val2);
12261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12262 if (!SWIG_IsOK(ecode3)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12264 }
12265 arg3 = static_cast< byte >(val3);
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj = 0;
12281 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12282 byte *arg2 = (byte *) 0 ;
12283 byte *arg3 = (byte *) 0 ;
12284 byte *arg4 = (byte *) 0 ;
12285 byte arg5 = (byte) 1 ;
12286 byte arg6 = (byte) 0 ;
12287 byte arg7 = (byte) 0 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 byte temp2 ;
12292 int res2 = SWIG_TMPOBJ ;
12293 byte temp3 ;
12294 int res3 = SWIG_TMPOBJ ;
12295 byte temp4 ;
12296 int res4 = SWIG_TMPOBJ ;
12297 unsigned char val5 ;
12298 int ecode5 = 0 ;
12299 unsigned char val6 ;
12300 int ecode6 = 0 ;
12301 unsigned char val7 ;
12302 int ecode7 = 0 ;
12303 PyObject * obj0 = 0 ;
12304 PyObject * obj1 = 0 ;
12305 PyObject * obj2 = 0 ;
12306 PyObject * obj3 = 0 ;
12307 char * kwnames[] = {
12308 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12309 };
12310
12311 arg2 = &temp2;
12312 arg3 = &temp3;
12313 arg4 = &temp4;
12314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12316 if (!SWIG_IsOK(res1)) {
12317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12318 }
12319 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12320 if (obj1) {
12321 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12322 if (!SWIG_IsOK(ecode5)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12324 }
12325 arg5 = static_cast< byte >(val5);
12326 }
12327 if (obj2) {
12328 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12329 if (!SWIG_IsOK(ecode6)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12331 }
12332 arg6 = static_cast< byte >(val6);
12333 }
12334 if (obj3) {
12335 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12336 if (!SWIG_IsOK(ecode7)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12338 }
12339 arg7 = static_cast< byte >(val7);
12340 }
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12349 }
12350 if (SWIG_IsTmpObj(res2)) {
12351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12352 } else {
12353 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12355 }
12356 if (SWIG_IsTmpObj(res3)) {
12357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12358 } else {
12359 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12361 }
12362 if (SWIG_IsTmpObj(res4)) {
12363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12364 } else {
12365 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj = 0;
12376 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12377 unsigned long arg2 ;
12378 unsigned long result;
12379 void *argp1 = 0 ;
12380 int res1 = 0 ;
12381 unsigned long val2 ;
12382 int ecode2 = 0 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "self",(char *) "key", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12395 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12398 }
12399 arg2 = static_cast< unsigned long >(val2);
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12416 byte arg2 ;
12417 byte arg3 ;
12418 byte arg4 ;
12419 unsigned long result;
12420 void *argp1 = 0 ;
12421 int res1 = 0 ;
12422 unsigned char val2 ;
12423 int ecode2 = 0 ;
12424 unsigned char val3 ;
12425 int ecode3 = 0 ;
12426 unsigned char val4 ;
12427 int ecode4 = 0 ;
12428 PyObject * obj0 = 0 ;
12429 PyObject * obj1 = 0 ;
12430 PyObject * obj2 = 0 ;
12431 PyObject * obj3 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12440 }
12441 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12442 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12443 if (!SWIG_IsOK(ecode2)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12445 }
12446 arg2 = static_cast< byte >(val2);
12447 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12448 if (!SWIG_IsOK(ecode3)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12450 }
12451 arg3 = static_cast< byte >(val3);
12452 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12453 if (!SWIG_IsOK(ecode4)) {
12454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12455 }
12456 arg4 = static_cast< byte >(val4);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = 0;
12472 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12473 wxColour *arg2 = 0 ;
12474 unsigned long result;
12475 void *argp1 = 0 ;
12476 int res1 = 0 ;
12477 wxColour temp2 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char * kwnames[] = {
12481 (char *) "self",(char *) "colour", NULL
12482 };
12483
12484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12488 }
12489 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12490 {
12491 arg2 = &temp2;
12492 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12493 }
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508 PyObject *obj;
12509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12510 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12511 return SWIG_Py_Void();
12512 }
12513
12514 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 return SWIG_Python_InitShadowInstance(args);
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 byte arg1 = (byte) 0 ;
12521 byte arg2 = (byte) 0 ;
12522 byte arg3 = (byte) 0 ;
12523 wxImage_RGBValue *result = 0 ;
12524 unsigned char val1 ;
12525 int ecode1 = 0 ;
12526 unsigned char val2 ;
12527 int ecode2 = 0 ;
12528 unsigned char val3 ;
12529 int ecode3 = 0 ;
12530 PyObject * obj0 = 0 ;
12531 PyObject * obj1 = 0 ;
12532 PyObject * obj2 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "r",(char *) "g",(char *) "b", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12538 if (obj0) {
12539 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12540 if (!SWIG_IsOK(ecode1)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12542 }
12543 arg1 = static_cast< byte >(val1);
12544 }
12545 if (obj1) {
12546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12547 if (!SWIG_IsOK(ecode2)) {
12548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12549 }
12550 arg2 = static_cast< byte >(val2);
12551 }
12552 if (obj2) {
12553 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12554 if (!SWIG_IsOK(ecode3)) {
12555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12556 }
12557 arg3 = static_cast< byte >(val3);
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 PyObject *resultobj = 0;
12574 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12575 byte arg2 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 unsigned char val2 ;
12579 int ecode2 = 0 ;
12580 PyObject *swig_obj[2] ;
12581
12582 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12584 if (!SWIG_IsOK(res1)) {
12585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12586 }
12587 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12588 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12589 if (!SWIG_IsOK(ecode2)) {
12590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12591 }
12592 arg2 = static_cast< byte >(val2);
12593 if (arg1) (arg1)->red = arg2;
12594
12595 resultobj = SWIG_Py_Void();
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12603 PyObject *resultobj = 0;
12604 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12605 byte result;
12606 void *argp1 = 0 ;
12607 int res1 = 0 ;
12608 PyObject *swig_obj[1] ;
12609
12610 if (!args) SWIG_fail;
12611 swig_obj[0] = args;
12612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12613 if (!SWIG_IsOK(res1)) {
12614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12615 }
12616 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12617 result = (byte) ((arg1)->red);
12618 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12619 return resultobj;
12620 fail:
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12628 byte arg2 ;
12629 void *argp1 = 0 ;
12630 int res1 = 0 ;
12631 unsigned char val2 ;
12632 int ecode2 = 0 ;
12633 PyObject *swig_obj[2] ;
12634
12635 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12637 if (!SWIG_IsOK(res1)) {
12638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12639 }
12640 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12641 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12644 }
12645 arg2 = static_cast< byte >(val2);
12646 if (arg1) (arg1)->green = arg2;
12647
12648 resultobj = SWIG_Py_Void();
12649 return resultobj;
12650 fail:
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656 PyObject *resultobj = 0;
12657 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12658 byte result;
12659 void *argp1 = 0 ;
12660 int res1 = 0 ;
12661 PyObject *swig_obj[1] ;
12662
12663 if (!args) SWIG_fail;
12664 swig_obj[0] = args;
12665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12666 if (!SWIG_IsOK(res1)) {
12667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12668 }
12669 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12670 result = (byte) ((arg1)->green);
12671 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679 PyObject *resultobj = 0;
12680 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12681 byte arg2 ;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 unsigned char val2 ;
12685 int ecode2 = 0 ;
12686 PyObject *swig_obj[2] ;
12687
12688 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12690 if (!SWIG_IsOK(res1)) {
12691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12692 }
12693 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12694 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12695 if (!SWIG_IsOK(ecode2)) {
12696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12697 }
12698 arg2 = static_cast< byte >(val2);
12699 if (arg1) (arg1)->blue = arg2;
12700
12701 resultobj = SWIG_Py_Void();
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 PyObject *resultobj = 0;
12710 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12711 byte result;
12712 void *argp1 = 0 ;
12713 int res1 = 0 ;
12714 PyObject *swig_obj[1] ;
12715
12716 if (!args) SWIG_fail;
12717 swig_obj[0] = args;
12718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12721 }
12722 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12723 result = (byte) ((arg1)->blue);
12724 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *obj;
12733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12734 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12735 return SWIG_Py_Void();
12736 }
12737
12738 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739 return SWIG_Python_InitShadowInstance(args);
12740 }
12741
12742 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 double arg1 = (double) 0.0 ;
12745 double arg2 = (double) 0.0 ;
12746 double arg3 = (double) 0.0 ;
12747 wxImage_HSVValue *result = 0 ;
12748 double val1 ;
12749 int ecode1 = 0 ;
12750 double val2 ;
12751 int ecode2 = 0 ;
12752 double val3 ;
12753 int ecode3 = 0 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 PyObject * obj2 = 0 ;
12757 char * kwnames[] = {
12758 (char *) "h",(char *) "s",(char *) "v", NULL
12759 };
12760
12761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12762 if (obj0) {
12763 ecode1 = SWIG_AsVal_double(obj0, &val1);
12764 if (!SWIG_IsOK(ecode1)) {
12765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12766 }
12767 arg1 = static_cast< double >(val1);
12768 }
12769 if (obj1) {
12770 ecode2 = SWIG_AsVal_double(obj1, &val2);
12771 if (!SWIG_IsOK(ecode2)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12773 }
12774 arg2 = static_cast< double >(val2);
12775 }
12776 if (obj2) {
12777 ecode3 = SWIG_AsVal_double(obj2, &val3);
12778 if (!SWIG_IsOK(ecode3)) {
12779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12780 }
12781 arg3 = static_cast< double >(val3);
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 PyObject *resultobj = 0;
12798 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12799 double arg2 ;
12800 void *argp1 = 0 ;
12801 int res1 = 0 ;
12802 double val2 ;
12803 int ecode2 = 0 ;
12804 PyObject *swig_obj[2] ;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12810 }
12811 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12812 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12813 if (!SWIG_IsOK(ecode2)) {
12814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12815 }
12816 arg2 = static_cast< double >(val2);
12817 if (arg1) (arg1)->hue = arg2;
12818
12819 resultobj = SWIG_Py_Void();
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 PyObject *resultobj = 0;
12828 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12829 double result;
12830 void *argp1 = 0 ;
12831 int res1 = 0 ;
12832 PyObject *swig_obj[1] ;
12833
12834 if (!args) SWIG_fail;
12835 swig_obj[0] = args;
12836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12837 if (!SWIG_IsOK(res1)) {
12838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12839 }
12840 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12841 result = (double) ((arg1)->hue);
12842 resultobj = SWIG_From_double(static_cast< double >(result));
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *resultobj = 0;
12851 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12852 double arg2 ;
12853 void *argp1 = 0 ;
12854 int res1 = 0 ;
12855 double val2 ;
12856 int ecode2 = 0 ;
12857 PyObject *swig_obj[2] ;
12858
12859 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12863 }
12864 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12865 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12866 if (!SWIG_IsOK(ecode2)) {
12867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12868 }
12869 arg2 = static_cast< double >(val2);
12870 if (arg1) (arg1)->saturation = arg2;
12871
12872 resultobj = SWIG_Py_Void();
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 PyObject *resultobj = 0;
12881 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12882 double result;
12883 void *argp1 = 0 ;
12884 int res1 = 0 ;
12885 PyObject *swig_obj[1] ;
12886
12887 if (!args) SWIG_fail;
12888 swig_obj[0] = args;
12889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12890 if (!SWIG_IsOK(res1)) {
12891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12892 }
12893 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12894 result = (double) ((arg1)->saturation);
12895 resultobj = SWIG_From_double(static_cast< double >(result));
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12905 double arg2 ;
12906 void *argp1 = 0 ;
12907 int res1 = 0 ;
12908 double val2 ;
12909 int ecode2 = 0 ;
12910 PyObject *swig_obj[2] ;
12911
12912 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12916 }
12917 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12918 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12919 if (!SWIG_IsOK(ecode2)) {
12920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12921 }
12922 arg2 = static_cast< double >(val2);
12923 if (arg1) (arg1)->value = arg2;
12924
12925 resultobj = SWIG_Py_Void();
12926 return resultobj;
12927 fail:
12928 return NULL;
12929 }
12930
12931
12932 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12933 PyObject *resultobj = 0;
12934 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12935 double result;
12936 void *argp1 = 0 ;
12937 int res1 = 0 ;
12938 PyObject *swig_obj[1] ;
12939
12940 if (!args) SWIG_fail;
12941 swig_obj[0] = args;
12942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12943 if (!SWIG_IsOK(res1)) {
12944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12945 }
12946 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12947 result = (double) ((arg1)->value);
12948 resultobj = SWIG_From_double(static_cast< double >(result));
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12956 PyObject *obj;
12957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12958 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12959 return SWIG_Py_Void();
12960 }
12961
12962 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 return SWIG_Python_InitShadowInstance(args);
12964 }
12965
12966 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj = 0;
12968 wxString *arg1 = 0 ;
12969 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12970 int arg3 = (int) -1 ;
12971 wxImage *result = 0 ;
12972 bool temp1 = false ;
12973 long val2 ;
12974 int ecode2 = 0 ;
12975 int val3 ;
12976 int ecode3 = 0 ;
12977 PyObject * obj0 = 0 ;
12978 PyObject * obj1 = 0 ;
12979 PyObject * obj2 = 0 ;
12980 char * kwnames[] = {
12981 (char *) "name",(char *) "type",(char *) "index", NULL
12982 };
12983
12984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12985 {
12986 arg1 = wxString_in_helper(obj0);
12987 if (arg1 == NULL) SWIG_fail;
12988 temp1 = true;
12989 }
12990 if (obj1) {
12991 ecode2 = SWIG_AsVal_long(obj1, &val2);
12992 if (!SWIG_IsOK(ecode2)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12994 }
12995 arg2 = static_cast< long >(val2);
12996 }
12997 if (obj2) {
12998 ecode3 = SWIG_AsVal_int(obj2, &val3);
12999 if (!SWIG_IsOK(ecode3)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13001 }
13002 arg3 = static_cast< int >(val3);
13003 }
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13011 {
13012 if (temp1)
13013 delete arg1;
13014 }
13015 return resultobj;
13016 fail:
13017 {
13018 if (temp1)
13019 delete arg1;
13020 }
13021 return NULL;
13022 }
13023
13024
13025 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026 PyObject *resultobj = 0;
13027 wxImage *arg1 = (wxImage *) 0 ;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 PyObject *swig_obj[1] ;
13031
13032 if (!args) SWIG_fail;
13033 swig_obj[0] = args;
13034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13037 }
13038 arg1 = reinterpret_cast< wxImage * >(argp1);
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 delete arg1;
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_Py_Void();
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj = 0;
13055 wxString *arg1 = 0 ;
13056 wxString *arg2 = 0 ;
13057 int arg3 = (int) -1 ;
13058 wxImage *result = 0 ;
13059 bool temp1 = false ;
13060 bool temp2 = false ;
13061 int val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 {
13072 arg1 = wxString_in_helper(obj0);
13073 if (arg1 == NULL) SWIG_fail;
13074 temp1 = true;
13075 }
13076 {
13077 arg2 = wxString_in_helper(obj1);
13078 if (arg2 == NULL) SWIG_fail;
13079 temp2 = true;
13080 }
13081 if (obj2) {
13082 ecode3 = SWIG_AsVal_int(obj2, &val3);
13083 if (!SWIG_IsOK(ecode3)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13085 }
13086 arg3 = static_cast< int >(val3);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13095 {
13096 if (temp1)
13097 delete arg1;
13098 }
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104 fail:
13105 {
13106 if (temp1)
13107 delete arg1;
13108 }
13109 {
13110 if (temp2)
13111 delete arg2;
13112 }
13113 return NULL;
13114 }
13115
13116
13117 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = 0;
13119 wxInputStream *arg1 = 0 ;
13120 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13121 int arg3 = (int) -1 ;
13122 wxImage *result = 0 ;
13123 wxPyInputStream *temp1 ;
13124 bool created1 ;
13125 long val2 ;
13126 int ecode2 = 0 ;
13127 int val3 ;
13128 int ecode3 = 0 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13131 PyObject * obj2 = 0 ;
13132 char * kwnames[] = {
13133 (char *) "stream",(char *) "type",(char *) "index", NULL
13134 };
13135
13136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13137 {
13138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13139 arg1 = temp1->m_wxis;
13140 created1 = false;
13141 } else {
13142 PyErr_Clear(); // clear the failure of the wxPyConvert above
13143 arg1 = wxPyCBInputStream_create(obj0, false);
13144 if (arg1 == NULL) {
13145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13146 SWIG_fail;
13147 }
13148 created1 = true;
13149 }
13150 }
13151 if (obj1) {
13152 ecode2 = SWIG_AsVal_long(obj1, &val2);
13153 if (!SWIG_IsOK(ecode2)) {
13154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13155 }
13156 arg2 = static_cast< long >(val2);
13157 }
13158 if (obj2) {
13159 ecode3 = SWIG_AsVal_int(obj2, &val3);
13160 if (!SWIG_IsOK(ecode3)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13162 }
13163 arg3 = static_cast< int >(val3);
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13172 {
13173 if (created1) delete arg1;
13174 }
13175 return resultobj;
13176 fail:
13177 {
13178 if (created1) delete arg1;
13179 }
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj = 0;
13186 wxInputStream *arg1 = 0 ;
13187 wxString *arg2 = 0 ;
13188 int arg3 = (int) -1 ;
13189 wxImage *result = 0 ;
13190 wxPyInputStream *temp1 ;
13191 bool created1 ;
13192 bool temp2 = false ;
13193 int val3 ;
13194 int ecode3 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 PyObject * obj2 = 0 ;
13198 char * kwnames[] = {
13199 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13200 };
13201
13202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13203 {
13204 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13205 arg1 = temp1->m_wxis;
13206 created1 = false;
13207 } else {
13208 PyErr_Clear(); // clear the failure of the wxPyConvert above
13209 arg1 = wxPyCBInputStream_create(obj0, false);
13210 if (arg1 == NULL) {
13211 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13212 SWIG_fail;
13213 }
13214 created1 = true;
13215 }
13216 }
13217 {
13218 arg2 = wxString_in_helper(obj1);
13219 if (arg2 == NULL) SWIG_fail;
13220 temp2 = true;
13221 }
13222 if (obj2) {
13223 ecode3 = SWIG_AsVal_int(obj2, &val3);
13224 if (!SWIG_IsOK(ecode3)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13226 }
13227 arg3 = static_cast< int >(val3);
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13236 {
13237 if (created1) delete arg1;
13238 }
13239 {
13240 if (temp2)
13241 delete arg2;
13242 }
13243 return resultobj;
13244 fail:
13245 {
13246 if (created1) delete arg1;
13247 }
13248 {
13249 if (temp2)
13250 delete arg2;
13251 }
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 int arg1 = (int) 0 ;
13259 int arg2 = (int) 0 ;
13260 bool arg3 = (bool) true ;
13261 wxImage *result = 0 ;
13262 int val1 ;
13263 int ecode1 = 0 ;
13264 int val2 ;
13265 int ecode2 = 0 ;
13266 bool val3 ;
13267 int ecode3 = 0 ;
13268 PyObject * obj0 = 0 ;
13269 PyObject * obj1 = 0 ;
13270 PyObject * obj2 = 0 ;
13271 char * kwnames[] = {
13272 (char *) "width",(char *) "height",(char *) "clear", NULL
13273 };
13274
13275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13276 if (obj0) {
13277 ecode1 = SWIG_AsVal_int(obj0, &val1);
13278 if (!SWIG_IsOK(ecode1)) {
13279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13280 }
13281 arg1 = static_cast< int >(val1);
13282 }
13283 if (obj1) {
13284 ecode2 = SWIG_AsVal_int(obj1, &val2);
13285 if (!SWIG_IsOK(ecode2)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13287 }
13288 arg2 = static_cast< int >(val2);
13289 }
13290 if (obj2) {
13291 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13292 if (!SWIG_IsOK(ecode3)) {
13293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13294 }
13295 arg3 = static_cast< bool >(val3);
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxBitmap *arg1 = 0 ;
13313 wxImage *result = 0 ;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 PyObject * obj0 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "bitmap", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13322 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13325 }
13326 if (!argp1) {
13327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13328 }
13329 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13330 {
13331 if (!wxPyCheckForApp()) SWIG_fail;
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj = 0;
13346 int arg1 ;
13347 int arg2 ;
13348 buffer arg3 ;
13349 int arg4 ;
13350 wxImage *result = 0 ;
13351 int val1 ;
13352 int ecode1 = 0 ;
13353 int val2 ;
13354 int ecode2 = 0 ;
13355 PyObject * obj0 = 0 ;
13356 PyObject * obj1 = 0 ;
13357 PyObject * obj2 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "width",(char *) "height",(char *) "data", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13363 ecode1 = SWIG_AsVal_int(obj0, &val1);
13364 if (!SWIG_IsOK(ecode1)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13366 }
13367 arg1 = static_cast< int >(val1);
13368 ecode2 = SWIG_AsVal_int(obj1, &val2);
13369 if (!SWIG_IsOK(ecode2)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13371 }
13372 arg2 = static_cast< int >(val2);
13373 {
13374 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj = 0;
13391 int arg1 ;
13392 int arg2 ;
13393 buffer arg3 ;
13394 int arg4 ;
13395 buffer arg5 ;
13396 int arg6 ;
13397 wxImage *result = 0 ;
13398 int val1 ;
13399 int ecode1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 PyObject * obj0 = 0 ;
13403 PyObject * obj1 = 0 ;
13404 PyObject * obj2 = 0 ;
13405 PyObject * obj3 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13411 ecode1 = SWIG_AsVal_int(obj0, &val1);
13412 if (!SWIG_IsOK(ecode1)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13414 }
13415 arg1 = static_cast< int >(val1);
13416 ecode2 = SWIG_AsVal_int(obj1, &val2);
13417 if (!SWIG_IsOK(ecode2)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13419 }
13420 arg2 = static_cast< int >(val2);
13421 {
13422 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13423 }
13424 {
13425 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13426 }
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj = 0;
13442 wxImage *arg1 = (wxImage *) 0 ;
13443 int arg2 ;
13444 int arg3 ;
13445 bool arg4 = (bool) true ;
13446 void *argp1 = 0 ;
13447 int res1 = 0 ;
13448 int val2 ;
13449 int ecode2 = 0 ;
13450 int val3 ;
13451 int ecode3 = 0 ;
13452 bool val4 ;
13453 int ecode4 = 0 ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 PyObject * obj2 = 0 ;
13457 PyObject * obj3 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13466 }
13467 arg1 = reinterpret_cast< wxImage * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 ecode3 = SWIG_AsVal_int(obj2, &val3);
13474 if (!SWIG_IsOK(ecode3)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13476 }
13477 arg3 = static_cast< int >(val3);
13478 if (obj3) {
13479 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13480 if (!SWIG_IsOK(ecode4)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13482 }
13483 arg4 = static_cast< bool >(val4);
13484 }
13485 {
13486 PyThreadState* __tstate = wxPyBeginAllowThreads();
13487 (arg1)->Create(arg2,arg3,arg4);
13488 wxPyEndAllowThreads(__tstate);
13489 if (PyErr_Occurred()) SWIG_fail;
13490 }
13491 resultobj = SWIG_Py_Void();
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxImage *arg1 = (wxImage *) 0 ;
13501 void *argp1 = 0 ;
13502 int res1 = 0 ;
13503 PyObject *swig_obj[1] ;
13504
13505 if (!args) SWIG_fail;
13506 swig_obj[0] = args;
13507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13508 if (!SWIG_IsOK(res1)) {
13509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13510 }
13511 arg1 = reinterpret_cast< wxImage * >(argp1);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 (arg1)->Destroy();
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 resultobj = SWIG_Py_Void();
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 int arg2 ;
13529 int arg3 ;
13530 SwigValueWrapper<wxImage > result;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 int val2 ;
13534 int ecode2 = 0 ;
13535 int val3 ;
13536 int ecode3 = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "width",(char *) "height", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13548 }
13549 arg1 = reinterpret_cast< wxImage * >(argp1);
13550 ecode2 = SWIG_AsVal_int(obj1, &val2);
13551 if (!SWIG_IsOK(ecode2)) {
13552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13553 }
13554 arg2 = static_cast< int >(val2);
13555 ecode3 = SWIG_AsVal_int(obj2, &val3);
13556 if (!SWIG_IsOK(ecode3)) {
13557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13558 }
13559 arg3 = static_cast< int >(val3);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = (arg1)->Scale(arg2,arg3);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 SwigValueWrapper<wxImage > result;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 PyObject * obj2 = 0 ;
13588 char * kwnames[] = {
13589 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13590 };
13591
13592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13596 }
13597 arg1 = reinterpret_cast< wxImage * >(argp1);
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 ecode3 = SWIG_AsVal_int(obj2, &val3);
13604 if (!SWIG_IsOK(ecode3)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13606 }
13607 arg3 = static_cast< int >(val3);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 int arg2 ;
13625 int arg3 ;
13626 wxImage *result = 0 ;
13627 void *argp1 = 0 ;
13628 int res1 = 0 ;
13629 int val2 ;
13630 int ecode2 = 0 ;
13631 int val3 ;
13632 int ecode3 = 0 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 PyObject * obj2 = 0 ;
13636 char * kwnames[] = {
13637 (char *) "self",(char *) "width",(char *) "height", NULL
13638 };
13639
13640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13642 if (!SWIG_IsOK(res1)) {
13643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13644 }
13645 arg1 = reinterpret_cast< wxImage * >(argp1);
13646 ecode2 = SWIG_AsVal_int(obj1, &val2);
13647 if (!SWIG_IsOK(ecode2)) {
13648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13649 }
13650 arg2 = static_cast< int >(val2);
13651 ecode3 = SWIG_AsVal_int(obj2, &val3);
13652 if (!SWIG_IsOK(ecode3)) {
13653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13654 }
13655 arg3 = static_cast< int >(val3);
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 {
13659 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13660 result = (wxImage *) &_result_ref;
13661 }
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13673 PyObject *resultobj = 0;
13674 wxImage *arg1 = (wxImage *) 0 ;
13675 wxSize *arg2 = 0 ;
13676 wxPoint *arg3 = 0 ;
13677 int arg4 = (int) -1 ;
13678 int arg5 = (int) -1 ;
13679 int arg6 = (int) -1 ;
13680 wxImage *result = 0 ;
13681 void *argp1 = 0 ;
13682 int res1 = 0 ;
13683 wxSize temp2 ;
13684 wxPoint temp3 ;
13685 int val4 ;
13686 int ecode4 = 0 ;
13687 int val5 ;
13688 int ecode5 = 0 ;
13689 int val6 ;
13690 int ecode6 = 0 ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 PyObject * obj2 = 0 ;
13694 PyObject * obj3 = 0 ;
13695 PyObject * obj4 = 0 ;
13696 PyObject * obj5 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 {
13708 arg2 = &temp2;
13709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13710 }
13711 {
13712 arg3 = &temp3;
13713 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13714 }
13715 if (obj3) {
13716 ecode4 = SWIG_AsVal_int(obj3, &val4);
13717 if (!SWIG_IsOK(ecode4)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13719 }
13720 arg4 = static_cast< int >(val4);
13721 }
13722 if (obj4) {
13723 ecode5 = SWIG_AsVal_int(obj4, &val5);
13724 if (!SWIG_IsOK(ecode5)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13726 }
13727 arg5 = static_cast< int >(val5);
13728 }
13729 if (obj5) {
13730 ecode6 = SWIG_AsVal_int(obj5, &val6);
13731 if (!SWIG_IsOK(ecode6)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13733 }
13734 arg6 = static_cast< int >(val6);
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 {
13739 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13740 result = (wxImage *) &_result_ref;
13741 }
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13746 return resultobj;
13747 fail:
13748 return NULL;
13749 }
13750
13751
13752 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13753 PyObject *resultobj = 0;
13754 wxImage *arg1 = (wxImage *) 0 ;
13755 int arg2 ;
13756 int arg3 ;
13757 byte arg4 ;
13758 byte arg5 ;
13759 byte arg6 ;
13760 void *argp1 = 0 ;
13761 int res1 = 0 ;
13762 int val2 ;
13763 int ecode2 = 0 ;
13764 int val3 ;
13765 int ecode3 = 0 ;
13766 unsigned char val4 ;
13767 int ecode4 = 0 ;
13768 unsigned char val5 ;
13769 int ecode5 = 0 ;
13770 unsigned char val6 ;
13771 int ecode6 = 0 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 PyObject * obj3 = 0 ;
13776 PyObject * obj4 = 0 ;
13777 PyObject * obj5 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13786 }
13787 arg1 = reinterpret_cast< wxImage * >(argp1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 if (!SWIG_IsOK(ecode3)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13796 }
13797 arg3 = static_cast< int >(val3);
13798 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13799 if (!SWIG_IsOK(ecode4)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13801 }
13802 arg4 = static_cast< byte >(val4);
13803 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13804 if (!SWIG_IsOK(ecode5)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13806 }
13807 arg5 = static_cast< byte >(val5);
13808 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13809 if (!SWIG_IsOK(ecode6)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13811 }
13812 arg6 = static_cast< byte >(val6);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 wxRect *arg2 = 0 ;
13830 byte arg3 ;
13831 byte arg4 ;
13832 byte arg5 ;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 wxRect temp2 ;
13836 unsigned char val3 ;
13837 int ecode3 = 0 ;
13838 unsigned char val4 ;
13839 int ecode4 = 0 ;
13840 unsigned char val5 ;
13841 int ecode5 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 PyObject * obj3 = 0 ;
13846 PyObject * obj4 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13853 if (!SWIG_IsOK(res1)) {
13854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13855 }
13856 arg1 = reinterpret_cast< wxImage * >(argp1);
13857 {
13858 arg2 = &temp2;
13859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13860 }
13861 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13864 }
13865 arg3 = static_cast< byte >(val3);
13866 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13867 if (!SWIG_IsOK(ecode4)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13869 }
13870 arg4 = static_cast< byte >(val4);
13871 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13872 if (!SWIG_IsOK(ecode5)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13874 }
13875 arg5 = static_cast< byte >(val5);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_Py_Void();
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxImage *arg1 = (wxImage *) 0 ;
13892 int arg2 ;
13893 int arg3 ;
13894 byte result;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 int val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (byte)(arg1)->GetRed(arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj = 0;
13939 wxImage *arg1 = (wxImage *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 byte result;
13943 void *argp1 = 0 ;
13944 int res1 = 0 ;
13945 int val2 ;
13946 int ecode2 = 0 ;
13947 int val3 ;
13948 int ecode3 = 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 PyObject * obj2 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "self",(char *) "x",(char *) "y", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13960 }
13961 arg1 = reinterpret_cast< wxImage * >(argp1);
13962 ecode2 = SWIG_AsVal_int(obj1, &val2);
13963 if (!SWIG_IsOK(ecode2)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13965 }
13966 arg2 = static_cast< int >(val2);
13967 ecode3 = SWIG_AsVal_int(obj2, &val3);
13968 if (!SWIG_IsOK(ecode3)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13970 }
13971 arg3 = static_cast< int >(val3);
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 result = (byte)(arg1)->GetGreen(arg2,arg3);
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = 0;
13987 wxImage *arg1 = (wxImage *) 0 ;
13988 int arg2 ;
13989 int arg3 ;
13990 byte result;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 int val2 ;
13994 int ecode2 = 0 ;
13995 int val3 ;
13996 int ecode3 = 0 ;
13997 PyObject * obj0 = 0 ;
13998 PyObject * obj1 = 0 ;
13999 PyObject * obj2 = 0 ;
14000 char * kwnames[] = {
14001 (char *) "self",(char *) "x",(char *) "y", NULL
14002 };
14003
14004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14008 }
14009 arg1 = reinterpret_cast< wxImage * >(argp1);
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14013 }
14014 arg2 = static_cast< int >(val2);
14015 ecode3 = SWIG_AsVal_int(obj2, &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14018 }
14019 arg3 = static_cast< int >(val3);
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 result = (byte)(arg1)->GetBlue(arg2,arg3);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxImage *arg1 = (wxImage *) 0 ;
14036 int arg2 ;
14037 int arg3 ;
14038 byte arg4 ;
14039 void *argp1 = 0 ;
14040 int res1 = 0 ;
14041 int val2 ;
14042 int ecode2 = 0 ;
14043 int val3 ;
14044 int ecode3 = 0 ;
14045 unsigned char val4 ;
14046 int ecode4 = 0 ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 PyObject * obj2 = 0 ;
14050 PyObject * obj3 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 ecode3 = SWIG_AsVal_int(obj2, &val3);
14067 if (!SWIG_IsOK(ecode3)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14069 }
14070 arg3 = static_cast< int >(val3);
14071 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14072 if (!SWIG_IsOK(ecode4)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14074 }
14075 arg4 = static_cast< byte >(val4);
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 (arg1)->SetAlpha(arg2,arg3,arg4);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxImage *arg1 = (wxImage *) 0 ;
14092 int arg2 ;
14093 int arg3 ;
14094 byte result;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 int val2 ;
14098 int ecode2 = 0 ;
14099 int val3 ;
14100 int ecode3 = 0 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "x",(char *) "y", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14112 }
14113 arg1 = reinterpret_cast< wxImage * >(argp1);
14114 ecode2 = SWIG_AsVal_int(obj1, &val2);
14115 if (!SWIG_IsOK(ecode2)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14117 }
14118 arg2 = static_cast< int >(val2);
14119 ecode3 = SWIG_AsVal_int(obj2, &val3);
14120 if (!SWIG_IsOK(ecode3)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14122 }
14123 arg3 = static_cast< int >(val3);
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14127 wxPyEndAllowThreads(__tstate);
14128 if (PyErr_Occurred()) SWIG_fail;
14129 }
14130 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14131 return resultobj;
14132 fail:
14133 return NULL;
14134 }
14135
14136
14137 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14138 PyObject *resultobj = 0;
14139 wxImage *arg1 = (wxImage *) 0 ;
14140 bool result;
14141 void *argp1 = 0 ;
14142 int res1 = 0 ;
14143 PyObject *swig_obj[1] ;
14144
14145 if (!args) SWIG_fail;
14146 swig_obj[0] = args;
14147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14148 if (!SWIG_IsOK(res1)) {
14149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14150 }
14151 arg1 = reinterpret_cast< wxImage * >(argp1);
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (bool)(arg1)->HasAlpha();
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 {
14159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14160 }
14161 return resultobj;
14162 fail:
14163 return NULL;
14164 }
14165
14166
14167 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 PyObject *resultobj = 0;
14169 wxImage *arg1 = (wxImage *) 0 ;
14170 void *argp1 = 0 ;
14171 int res1 = 0 ;
14172 PyObject *swig_obj[1] ;
14173
14174 if (!args) SWIG_fail;
14175 swig_obj[0] = args;
14176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 (arg1)->InitAlpha();
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 resultobj = SWIG_Py_Void();
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj = 0;
14196 wxImage *arg1 = (wxImage *) 0 ;
14197 int arg2 ;
14198 int arg3 ;
14199 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14200 bool result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 int val2 ;
14204 int ecode2 = 0 ;
14205 int val3 ;
14206 int ecode3 = 0 ;
14207 unsigned char val4 ;
14208 int ecode4 = 0 ;
14209 PyObject * obj0 = 0 ;
14210 PyObject * obj1 = 0 ;
14211 PyObject * obj2 = 0 ;
14212 PyObject * obj3 = 0 ;
14213 char * kwnames[] = {
14214 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14215 };
14216
14217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14221 }
14222 arg1 = reinterpret_cast< wxImage * >(argp1);
14223 ecode2 = SWIG_AsVal_int(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14226 }
14227 arg2 = static_cast< int >(val2);
14228 ecode3 = SWIG_AsVal_int(obj2, &val3);
14229 if (!SWIG_IsOK(ecode3)) {
14230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14231 }
14232 arg3 = static_cast< int >(val3);
14233 if (obj3) {
14234 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14235 if (!SWIG_IsOK(ecode4)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14237 }
14238 arg4 = static_cast< byte >(val4);
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 {
14247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14248 }
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 wxImage *arg1 = (wxImage *) 0 ;
14258 byte *arg2 = (byte *) 0 ;
14259 byte *arg3 = (byte *) 0 ;
14260 byte *arg4 = (byte *) 0 ;
14261 byte arg5 = (byte) 0 ;
14262 byte arg6 = (byte) 0 ;
14263 byte arg7 = (byte) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 byte temp2 ;
14268 int res2 = SWIG_TMPOBJ ;
14269 byte temp3 ;
14270 int res3 = SWIG_TMPOBJ ;
14271 byte temp4 ;
14272 int res4 = SWIG_TMPOBJ ;
14273 unsigned char val5 ;
14274 int ecode5 = 0 ;
14275 unsigned char val6 ;
14276 int ecode6 = 0 ;
14277 unsigned char val7 ;
14278 int ecode7 = 0 ;
14279 PyObject * obj0 = 0 ;
14280 PyObject * obj1 = 0 ;
14281 PyObject * obj2 = 0 ;
14282 PyObject * obj3 = 0 ;
14283 char * kwnames[] = {
14284 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14285 };
14286
14287 arg2 = &temp2;
14288 arg3 = &temp3;
14289 arg4 = &temp4;
14290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14292 if (!SWIG_IsOK(res1)) {
14293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14294 }
14295 arg1 = reinterpret_cast< wxImage * >(argp1);
14296 if (obj1) {
14297 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14298 if (!SWIG_IsOK(ecode5)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14300 }
14301 arg5 = static_cast< byte >(val5);
14302 }
14303 if (obj2) {
14304 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14305 if (!SWIG_IsOK(ecode6)) {
14306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14307 }
14308 arg6 = static_cast< byte >(val6);
14309 }
14310 if (obj3) {
14311 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14312 if (!SWIG_IsOK(ecode7)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14314 }
14315 arg7 = static_cast< byte >(val7);
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14325 }
14326 if (SWIG_IsTmpObj(res2)) {
14327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14328 } else {
14329 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14331 }
14332 if (SWIG_IsTmpObj(res3)) {
14333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14334 } else {
14335 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14337 }
14338 if (SWIG_IsTmpObj(res4)) {
14339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14340 } else {
14341 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14343 }
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj = 0;
14352 wxImage *arg1 = (wxImage *) 0 ;
14353 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14354 bool result;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 unsigned char val2 ;
14358 int ecode2 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 char * kwnames[] = {
14362 (char *) "self",(char *) "threshold", NULL
14363 };
14364
14365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14369 }
14370 arg1 = reinterpret_cast< wxImage * >(argp1);
14371 if (obj1) {
14372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14373 if (!SWIG_IsOK(ecode2)) {
14374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14375 }
14376 arg2 = static_cast< byte >(val2);
14377 }
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj = 0;
14395 wxImage *arg1 = (wxImage *) 0 ;
14396 byte arg2 ;
14397 byte arg3 ;
14398 byte arg4 ;
14399 bool result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 unsigned char val2 ;
14403 int ecode2 = 0 ;
14404 unsigned char val3 ;
14405 int ecode3 = 0 ;
14406 unsigned char val4 ;
14407 int ecode4 = 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 PyObject * obj2 = 0 ;
14411 PyObject * obj3 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14423 if (!SWIG_IsOK(ecode2)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14425 }
14426 arg2 = static_cast< byte >(val2);
14427 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14428 if (!SWIG_IsOK(ecode3)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14430 }
14431 arg3 = static_cast< byte >(val3);
14432 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14433 if (!SWIG_IsOK(ecode4)) {
14434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14435 }
14436 arg4 = static_cast< byte >(val4);
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 {
14444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14445 }
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14453 PyObject *resultobj = 0;
14454 wxImage *arg1 = (wxImage *) 0 ;
14455 wxImage *arg2 = 0 ;
14456 byte arg3 ;
14457 byte arg4 ;
14458 byte arg5 ;
14459 bool result;
14460 void *argp1 = 0 ;
14461 int res1 = 0 ;
14462 void *argp2 = 0 ;
14463 int res2 = 0 ;
14464 unsigned char val3 ;
14465 int ecode3 = 0 ;
14466 unsigned char val4 ;
14467 int ecode4 = 0 ;
14468 unsigned char val5 ;
14469 int ecode5 = 0 ;
14470 PyObject * obj0 = 0 ;
14471 PyObject * obj1 = 0 ;
14472 PyObject * obj2 = 0 ;
14473 PyObject * obj3 = 0 ;
14474 PyObject * obj4 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14483 }
14484 arg1 = reinterpret_cast< wxImage * >(argp1);
14485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14486 if (!SWIG_IsOK(res2)) {
14487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14488 }
14489 if (!argp2) {
14490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14491 }
14492 arg2 = reinterpret_cast< wxImage * >(argp2);
14493 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14494 if (!SWIG_IsOK(ecode3)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14496 }
14497 arg3 = static_cast< byte >(val3);
14498 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14499 if (!SWIG_IsOK(ecode4)) {
14500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14501 }
14502 arg4 = static_cast< byte >(val4);
14503 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14504 if (!SWIG_IsOK(ecode5)) {
14505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14506 }
14507 arg5 = static_cast< byte >(val5);
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 {
14515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14516 }
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj = 0;
14525 wxString *arg1 = 0 ;
14526 bool result;
14527 bool temp1 = false ;
14528 PyObject * obj0 = 0 ;
14529 char * kwnames[] = {
14530 (char *) "filename", NULL
14531 };
14532
14533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14534 {
14535 arg1 = wxString_in_helper(obj0);
14536 if (arg1 == NULL) SWIG_fail;
14537 temp1 = true;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 {
14546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14547 }
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp1)
14556 delete arg1;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxString *arg1 = 0 ;
14565 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14566 int result;
14567 bool temp1 = false ;
14568 long val2 ;
14569 int ecode2 = 0 ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "filename",(char *) "type", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14577 {
14578 arg1 = wxString_in_helper(obj0);
14579 if (arg1 == NULL) SWIG_fail;
14580 temp1 = true;
14581 }
14582 if (obj1) {
14583 ecode2 = SWIG_AsVal_long(obj1, &val2);
14584 if (!SWIG_IsOK(ecode2)) {
14585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14586 }
14587 arg2 = static_cast< long >(val2);
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_From_int(static_cast< int >(result));
14596 {
14597 if (temp1)
14598 delete arg1;
14599 }
14600 return resultobj;
14601 fail:
14602 {
14603 if (temp1)
14604 delete arg1;
14605 }
14606 return NULL;
14607 }
14608
14609
14610 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj = 0;
14612 wxImage *arg1 = (wxImage *) 0 ;
14613 wxString *arg2 = 0 ;
14614 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14615 int arg4 = (int) -1 ;
14616 bool result;
14617 void *argp1 = 0 ;
14618 int res1 = 0 ;
14619 bool temp2 = false ;
14620 long val3 ;
14621 int ecode3 = 0 ;
14622 int val4 ;
14623 int ecode4 = 0 ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 PyObject * obj2 = 0 ;
14627 PyObject * obj3 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImage * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 if (obj2) {
14644 ecode3 = SWIG_AsVal_long(obj2, &val3);
14645 if (!SWIG_IsOK(ecode3)) {
14646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14647 }
14648 arg3 = static_cast< long >(val3);
14649 }
14650 if (obj3) {
14651 ecode4 = SWIG_AsVal_int(obj3, &val4);
14652 if (!SWIG_IsOK(ecode4)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14654 }
14655 arg4 = static_cast< int >(val4);
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 {
14667 if (temp2)
14668 delete arg2;
14669 }
14670 return resultobj;
14671 fail:
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 return NULL;
14677 }
14678
14679
14680 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14681 PyObject *resultobj = 0;
14682 wxImage *arg1 = (wxImage *) 0 ;
14683 wxString *arg2 = 0 ;
14684 wxString *arg3 = 0 ;
14685 int arg4 = (int) -1 ;
14686 bool result;
14687 void *argp1 = 0 ;
14688 int res1 = 0 ;
14689 bool temp2 = false ;
14690 bool temp3 = false ;
14691 int val4 ;
14692 int ecode4 = 0 ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 PyObject * obj3 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14705 }
14706 arg1 = reinterpret_cast< wxImage * >(argp1);
14707 {
14708 arg2 = wxString_in_helper(obj1);
14709 if (arg2 == NULL) SWIG_fail;
14710 temp2 = true;
14711 }
14712 {
14713 arg3 = wxString_in_helper(obj2);
14714 if (arg3 == NULL) SWIG_fail;
14715 temp3 = true;
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_LoadMimeFile" "', 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,(wxString const &)*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 {
14738 if (temp3)
14739 delete arg3;
14740 }
14741 return resultobj;
14742 fail:
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return NULL;
14752 }
14753
14754
14755 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14756 PyObject *resultobj = 0;
14757 wxImage *arg1 = (wxImage *) 0 ;
14758 wxString *arg2 = 0 ;
14759 int arg3 ;
14760 bool result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 bool temp2 = false ;
14764 int val3 ;
14765 int ecode3 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 PyObject * obj2 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "name",(char *) "type", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14777 }
14778 arg1 = reinterpret_cast< wxImage * >(argp1);
14779 {
14780 arg2 = wxString_in_helper(obj1);
14781 if (arg2 == NULL) SWIG_fail;
14782 temp2 = true;
14783 }
14784 ecode3 = SWIG_AsVal_int(obj2, &val3);
14785 if (!SWIG_IsOK(ecode3)) {
14786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14787 }
14788 arg3 = static_cast< int >(val3);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (temp2)
14800 delete arg2;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj = 0;
14814 wxImage *arg1 = (wxImage *) 0 ;
14815 wxString *arg2 = 0 ;
14816 wxString *arg3 = 0 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 bool temp2 = false ;
14821 bool temp3 = false ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 char * kwnames[] = {
14826 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14827 };
14828
14829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14833 }
14834 arg1 = reinterpret_cast< wxImage * >(argp1);
14835 {
14836 arg2 = wxString_in_helper(obj1);
14837 if (arg2 == NULL) SWIG_fail;
14838 temp2 = true;
14839 }
14840 {
14841 arg3 = wxString_in_helper(obj2);
14842 if (arg3 == NULL) SWIG_fail;
14843 temp3 = true;
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 {
14855 if (temp2)
14856 delete arg2;
14857 }
14858 {
14859 if (temp3)
14860 delete arg3;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (temp2)
14866 delete arg2;
14867 }
14868 {
14869 if (temp3)
14870 delete arg3;
14871 }
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxInputStream *arg1 = 0 ;
14879 bool result;
14880 wxPyInputStream *temp1 ;
14881 bool created1 ;
14882 PyObject * obj0 = 0 ;
14883 char * kwnames[] = {
14884 (char *) "stream", NULL
14885 };
14886
14887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14888 {
14889 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14890 arg1 = temp1->m_wxis;
14891 created1 = false;
14892 } else {
14893 PyErr_Clear(); // clear the failure of the wxPyConvert above
14894 arg1 = wxPyCBInputStream_create(obj0, false);
14895 if (arg1 == NULL) {
14896 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14897 SWIG_fail;
14898 }
14899 created1 = true;
14900 }
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxImage::CanRead(*arg1);
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 {
14909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14910 }
14911 {
14912 if (created1) delete arg1;
14913 }
14914 return resultobj;
14915 fail:
14916 {
14917 if (created1) delete arg1;
14918 }
14919 return NULL;
14920 }
14921
14922
14923 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj = 0;
14925 wxImage *arg1 = (wxImage *) 0 ;
14926 wxInputStream *arg2 = 0 ;
14927 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14928 int arg4 = (int) -1 ;
14929 bool result;
14930 void *argp1 = 0 ;
14931 int res1 = 0 ;
14932 wxPyInputStream *temp2 ;
14933 bool created2 ;
14934 long val3 ;
14935 int ecode3 = 0 ;
14936 int val4 ;
14937 int ecode4 = 0 ;
14938 PyObject * obj0 = 0 ;
14939 PyObject * obj1 = 0 ;
14940 PyObject * obj2 = 0 ;
14941 PyObject * obj3 = 0 ;
14942 char * kwnames[] = {
14943 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14944 };
14945
14946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 {
14953 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14954 arg2 = temp2->m_wxis;
14955 created2 = false;
14956 } else {
14957 PyErr_Clear(); // clear the failure of the wxPyConvert above
14958 arg2 = wxPyCBInputStream_create(obj1, false);
14959 if (arg2 == NULL) {
14960 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14961 SWIG_fail;
14962 }
14963 created2 = true;
14964 }
14965 }
14966 if (obj2) {
14967 ecode3 = SWIG_AsVal_long(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14970 }
14971 arg3 = static_cast< long >(val3);
14972 }
14973 if (obj3) {
14974 ecode4 = SWIG_AsVal_int(obj3, &val4);
14975 if (!SWIG_IsOK(ecode4)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14977 }
14978 arg4 = static_cast< int >(val4);
14979 }
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 {
14987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14988 }
14989 {
14990 if (created2) delete arg2;
14991 }
14992 return resultobj;
14993 fail:
14994 {
14995 if (created2) delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 wxInputStream *arg2 = 0 ;
15005 wxString *arg3 = 0 ;
15006 int arg4 = (int) -1 ;
15007 bool result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 wxPyInputStream *temp2 ;
15011 bool created2 ;
15012 bool temp3 = false ;
15013 int val4 ;
15014 int ecode4 = 0 ;
15015 PyObject * obj0 = 0 ;
15016 PyObject * obj1 = 0 ;
15017 PyObject * obj2 = 0 ;
15018 PyObject * obj3 = 0 ;
15019 char * kwnames[] = {
15020 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15021 };
15022
15023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15027 }
15028 arg1 = reinterpret_cast< wxImage * >(argp1);
15029 {
15030 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15031 arg2 = temp2->m_wxis;
15032 created2 = false;
15033 } else {
15034 PyErr_Clear(); // clear the failure of the wxPyConvert above
15035 arg2 = wxPyCBInputStream_create(obj1, false);
15036 if (arg2 == NULL) {
15037 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15038 SWIG_fail;
15039 }
15040 created2 = true;
15041 }
15042 }
15043 {
15044 arg3 = wxString_in_helper(obj2);
15045 if (arg3 == NULL) SWIG_fail;
15046 temp3 = true;
15047 }
15048 if (obj3) {
15049 ecode4 = SWIG_AsVal_int(obj3, &val4);
15050 if (!SWIG_IsOK(ecode4)) {
15051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15052 }
15053 arg4 = static_cast< int >(val4);
15054 }
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 {
15062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15063 }
15064 {
15065 if (created2) delete arg2;
15066 }
15067 {
15068 if (temp3)
15069 delete arg3;
15070 }
15071 return resultobj;
15072 fail:
15073 {
15074 if (created2) delete arg2;
15075 }
15076 {
15077 if (temp3)
15078 delete arg3;
15079 }
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15085 PyObject *resultobj = 0;
15086 wxImage *arg1 = (wxImage *) 0 ;
15087 bool result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 PyObject *swig_obj[1] ;
15091
15092 if (!args) SWIG_fail;
15093 swig_obj[0] = args;
15094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15095 if (!SWIG_IsOK(res1)) {
15096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15097 }
15098 arg1 = reinterpret_cast< wxImage * >(argp1);
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (bool)(arg1)->Ok();
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 {
15106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15107 }
15108 return resultobj;
15109 fail:
15110 return NULL;
15111 }
15112
15113
15114 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15115 PyObject *resultobj = 0;
15116 wxImage *arg1 = (wxImage *) 0 ;
15117 int result;
15118 void *argp1 = 0 ;
15119 int res1 = 0 ;
15120 PyObject *swig_obj[1] ;
15121
15122 if (!args) SWIG_fail;
15123 swig_obj[0] = args;
15124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15125 if (!SWIG_IsOK(res1)) {
15126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15127 }
15128 arg1 = reinterpret_cast< wxImage * >(argp1);
15129 {
15130 PyThreadState* __tstate = wxPyBeginAllowThreads();
15131 result = (int)(arg1)->GetWidth();
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_From_int(static_cast< int >(result));
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 PyObject *resultobj = 0;
15144 wxImage *arg1 = (wxImage *) 0 ;
15145 int result;
15146 void *argp1 = 0 ;
15147 int res1 = 0 ;
15148 PyObject *swig_obj[1] ;
15149
15150 if (!args) SWIG_fail;
15151 swig_obj[0] = args;
15152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage * >(argp1);
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 result = (int)(arg1)->GetHeight();
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 resultobj = SWIG_From_int(static_cast< int >(result));
15164 return resultobj;
15165 fail:
15166 return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171 PyObject *resultobj = 0;
15172 wxImage *arg1 = (wxImage *) 0 ;
15173 wxSize result;
15174 void *argp1 = 0 ;
15175 int res1 = 0 ;
15176 PyObject *swig_obj[1] ;
15177
15178 if (!args) SWIG_fail;
15179 swig_obj[0] = args;
15180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15181 if (!SWIG_IsOK(res1)) {
15182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15183 }
15184 arg1 = reinterpret_cast< wxImage * >(argp1);
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 result = wxImage_GetSize(arg1);
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = 0;
15200 wxImage *arg1 = (wxImage *) 0 ;
15201 wxRect *arg2 = 0 ;
15202 SwigValueWrapper<wxImage > result;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 wxRect temp2 ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 char * kwnames[] = {
15209 (char *) "self",(char *) "rect", NULL
15210 };
15211
15212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 arg2 = &temp2;
15220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15221 }
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj = 0;
15237 wxImage *arg1 = (wxImage *) 0 ;
15238 wxSize *arg2 = 0 ;
15239 wxPoint *arg3 = 0 ;
15240 int arg4 = (int) -1 ;
15241 int arg5 = (int) -1 ;
15242 int arg6 = (int) -1 ;
15243 SwigValueWrapper<wxImage > result;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 wxSize temp2 ;
15247 wxPoint temp3 ;
15248 int val4 ;
15249 int ecode4 = 0 ;
15250 int val5 ;
15251 int ecode5 = 0 ;
15252 int val6 ;
15253 int ecode6 = 0 ;
15254 PyObject * obj0 = 0 ;
15255 PyObject * obj1 = 0 ;
15256 PyObject * obj2 = 0 ;
15257 PyObject * obj3 = 0 ;
15258 PyObject * obj4 = 0 ;
15259 PyObject * obj5 = 0 ;
15260 char * kwnames[] = {
15261 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15262 };
15263
15264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15268 }
15269 arg1 = reinterpret_cast< wxImage * >(argp1);
15270 {
15271 arg2 = &temp2;
15272 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15273 }
15274 {
15275 arg3 = &temp3;
15276 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15277 }
15278 if (obj3) {
15279 ecode4 = SWIG_AsVal_int(obj3, &val4);
15280 if (!SWIG_IsOK(ecode4)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15282 }
15283 arg4 = static_cast< int >(val4);
15284 }
15285 if (obj4) {
15286 ecode5 = SWIG_AsVal_int(obj4, &val5);
15287 if (!SWIG_IsOK(ecode5)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15289 }
15290 arg5 = static_cast< int >(val5);
15291 }
15292 if (obj5) {
15293 ecode6 = SWIG_AsVal_int(obj5, &val6);
15294 if (!SWIG_IsOK(ecode6)) {
15295 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15296 }
15297 arg6 = static_cast< int >(val6);
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15313 PyObject *resultobj = 0;
15314 wxImage *arg1 = (wxImage *) 0 ;
15315 SwigValueWrapper<wxImage > result;
15316 void *argp1 = 0 ;
15317 int res1 = 0 ;
15318 PyObject *swig_obj[1] ;
15319
15320 if (!args) SWIG_fail;
15321 swig_obj[0] = args;
15322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage * >(argp1);
15327 {
15328 PyThreadState* __tstate = wxPyBeginAllowThreads();
15329 result = (arg1)->Copy();
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj = 0;
15342 wxImage *arg1 = (wxImage *) 0 ;
15343 wxImage *arg2 = 0 ;
15344 int arg3 ;
15345 int arg4 ;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 void *argp2 = 0 ;
15349 int res2 = 0 ;
15350 int val3 ;
15351 int ecode3 = 0 ;
15352 int val4 ;
15353 int ecode4 = 0 ;
15354 PyObject * obj0 = 0 ;
15355 PyObject * obj1 = 0 ;
15356 PyObject * obj2 = 0 ;
15357 PyObject * obj3 = 0 ;
15358 char * kwnames[] = {
15359 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15360 };
15361
15362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15364 if (!SWIG_IsOK(res1)) {
15365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15366 }
15367 arg1 = reinterpret_cast< wxImage * >(argp1);
15368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15369 if (!SWIG_IsOK(res2)) {
15370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15371 }
15372 if (!argp2) {
15373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15374 }
15375 arg2 = reinterpret_cast< wxImage * >(argp2);
15376 ecode3 = SWIG_AsVal_int(obj2, &val3);
15377 if (!SWIG_IsOK(ecode3)) {
15378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15379 }
15380 arg3 = static_cast< int >(val3);
15381 ecode4 = SWIG_AsVal_int(obj3, &val4);
15382 if (!SWIG_IsOK(ecode4)) {
15383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15384 }
15385 arg4 = static_cast< int >(val4);
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage *arg1 = (wxImage *) 0 ;
15402 PyObject *result = 0 ;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (PyObject *)wxImage_GetData(arg1);
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj = 0;
15429 wxImage *arg1 = (wxImage *) 0 ;
15430 buffer arg2 ;
15431 int arg3 ;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "data", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 wxImage_SetData(arg1,arg2,arg3);
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_Py_Void();
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 PyObject *resultobj = 0;
15464 wxImage *arg1 = (wxImage *) 0 ;
15465 PyObject *result = 0 ;
15466 void *argp1 = 0 ;
15467 int res1 = 0 ;
15468 PyObject *swig_obj[1] ;
15469
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = result;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj = 0;
15492 wxImage *arg1 = (wxImage *) 0 ;
15493 buffer arg2 ;
15494 int arg3 ;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "self",(char *) "data", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage * >(argp1);
15509 {
15510 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 wxImage_SetDataBuffer(arg1,arg2,arg3);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 PyObject *result = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15538 }
15539 arg1 = reinterpret_cast< wxImage * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (PyObject *)wxImage_GetAlphaData(arg1);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = result;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxImage *arg1 = (wxImage *) 0 ;
15556 buffer arg2 ;
15557 int arg3 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "alpha", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetAlphaData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 char * kwnames[] = {
15626 (char *) "self",(char *) "alpha", NULL
15627 };
15628
15629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15633 }
15634 arg1 = reinterpret_cast< wxImage * >(argp1);
15635 {
15636 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15637 }
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 byte arg2 ;
15655 byte arg3 ;
15656 byte arg4 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 unsigned char val2 ;
15660 int ecode2 = 0 ;
15661 unsigned char val3 ;
15662 int ecode3 = 0 ;
15663 unsigned char val4 ;
15664 int ecode4 = 0 ;
15665 PyObject * obj0 = 0 ;
15666 PyObject * obj1 = 0 ;
15667 PyObject * obj2 = 0 ;
15668 PyObject * obj3 = 0 ;
15669 char * kwnames[] = {
15670 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15671 };
15672
15673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15677 }
15678 arg1 = reinterpret_cast< wxImage * >(argp1);
15679 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15680 if (!SWIG_IsOK(ecode2)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15682 }
15683 arg2 = static_cast< byte >(val2);
15684 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15685 if (!SWIG_IsOK(ecode3)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15687 }
15688 arg3 = static_cast< byte >(val3);
15689 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15690 if (!SWIG_IsOK(ecode4)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15692 }
15693 arg4 = static_cast< byte >(val4);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->SetMaskColour(arg2,arg3,arg4);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 byte *arg2 = (byte *) 0 ;
15711 byte *arg3 = (byte *) 0 ;
15712 byte *arg4 = (byte *) 0 ;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 byte temp2 ;
15716 int res2 = SWIG_TMPOBJ ;
15717 byte temp3 ;
15718 int res3 = SWIG_TMPOBJ ;
15719 byte temp4 ;
15720 int res4 = SWIG_TMPOBJ ;
15721 PyObject *swig_obj[1] ;
15722
15723 arg2 = &temp2;
15724 arg3 = &temp3;
15725 arg4 = &temp4;
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15731 }
15732 arg1 = reinterpret_cast< wxImage * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_Py_Void();
15740 if (SWIG_IsTmpObj(res2)) {
15741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15742 } else {
15743 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15745 }
15746 if (SWIG_IsTmpObj(res3)) {
15747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15748 } else {
15749 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15751 }
15752 if (SWIG_IsTmpObj(res4)) {
15753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15754 } else {
15755 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 byte result;
15768 void *argp1 = 0 ;
15769 int res1 = 0 ;
15770 PyObject *swig_obj[1] ;
15771
15772 if (!args) SWIG_fail;
15773 swig_obj[0] = args;
15774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15775 if (!SWIG_IsOK(res1)) {
15776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15777 }
15778 arg1 = reinterpret_cast< wxImage * >(argp1);
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (byte)(arg1)->GetMaskRed();
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15793 PyObject *resultobj = 0;
15794 wxImage *arg1 = (wxImage *) 0 ;
15795 byte result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 PyObject *swig_obj[1] ;
15799
15800 if (!args) SWIG_fail;
15801 swig_obj[0] = args;
15802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15803 if (!SWIG_IsOK(res1)) {
15804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15805 }
15806 arg1 = reinterpret_cast< wxImage * >(argp1);
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (byte)(arg1)->GetMaskGreen();
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15821 PyObject *resultobj = 0;
15822 wxImage *arg1 = (wxImage *) 0 ;
15823 byte result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 PyObject *swig_obj[1] ;
15827
15828 if (!args) SWIG_fail;
15829 swig_obj[0] = args;
15830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (byte)(arg1)->GetMaskBlue();
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 wxImage *arg1 = (wxImage *) 0 ;
15851 bool arg2 = (bool) true ;
15852 void *argp1 = 0 ;
15853 int res1 = 0 ;
15854 bool val2 ;
15855 int ecode2 = 0 ;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 char * kwnames[] = {
15859 (char *) "self",(char *) "mask", NULL
15860 };
15861
15862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15864 if (!SWIG_IsOK(res1)) {
15865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15866 }
15867 arg1 = reinterpret_cast< wxImage * >(argp1);
15868 if (obj1) {
15869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15870 if (!SWIG_IsOK(ecode2)) {
15871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15872 }
15873 arg2 = static_cast< bool >(val2);
15874 }
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 (arg1)->SetMask(arg2);
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 resultobj = SWIG_Py_Void();
15882 return resultobj;
15883 fail:
15884 return NULL;
15885 }
15886
15887
15888 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15889 PyObject *resultobj = 0;
15890 wxImage *arg1 = (wxImage *) 0 ;
15891 bool result;
15892 void *argp1 = 0 ;
15893 int res1 = 0 ;
15894 PyObject *swig_obj[1] ;
15895
15896 if (!args) SWIG_fail;
15897 swig_obj[0] = args;
15898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (bool)(arg1)->HasMask();
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 {
15910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15911 }
15912 return resultobj;
15913 fail:
15914 return NULL;
15915 }
15916
15917
15918 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15919 PyObject *resultobj = 0;
15920 wxImage *arg1 = (wxImage *) 0 ;
15921 double arg2 ;
15922 wxPoint *arg3 = 0 ;
15923 bool arg4 = (bool) true ;
15924 wxPoint *arg5 = (wxPoint *) NULL ;
15925 SwigValueWrapper<wxImage > result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 double val2 ;
15929 int ecode2 = 0 ;
15930 wxPoint temp3 ;
15931 bool val4 ;
15932 int ecode4 = 0 ;
15933 void *argp5 = 0 ;
15934 int res5 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 PyObject * obj2 = 0 ;
15938 PyObject * obj3 = 0 ;
15939 PyObject * obj4 = 0 ;
15940 char * kwnames[] = {
15941 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15942 };
15943
15944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15946 if (!SWIG_IsOK(res1)) {
15947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15948 }
15949 arg1 = reinterpret_cast< wxImage * >(argp1);
15950 ecode2 = SWIG_AsVal_double(obj1, &val2);
15951 if (!SWIG_IsOK(ecode2)) {
15952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15953 }
15954 arg2 = static_cast< double >(val2);
15955 {
15956 arg3 = &temp3;
15957 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15958 }
15959 if (obj3) {
15960 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15961 if (!SWIG_IsOK(ecode4)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15963 }
15964 arg4 = static_cast< bool >(val4);
15965 }
15966 if (obj4) {
15967 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15968 if (!SWIG_IsOK(res5)) {
15969 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15970 }
15971 arg5 = reinterpret_cast< wxPoint * >(argp5);
15972 }
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj = 0;
15988 wxImage *arg1 = (wxImage *) 0 ;
15989 bool arg2 = (bool) true ;
15990 SwigValueWrapper<wxImage > result;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 bool val2 ;
15994 int ecode2 = 0 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char * kwnames[] = {
15998 (char *) "self",(char *) "clockwise", NULL
15999 };
16000
16001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16005 }
16006 arg1 = reinterpret_cast< wxImage * >(argp1);
16007 if (obj1) {
16008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16009 if (!SWIG_IsOK(ecode2)) {
16010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16011 }
16012 arg2 = static_cast< bool >(val2);
16013 }
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (arg1)->Rotate90(arg2);
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj = 0;
16029 wxImage *arg1 = (wxImage *) 0 ;
16030 bool arg2 = (bool) true ;
16031 SwigValueWrapper<wxImage > result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 bool val2 ;
16035 int ecode2 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "self",(char *) "horizontally", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16046 }
16047 arg1 = reinterpret_cast< wxImage * >(argp1);
16048 if (obj1) {
16049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16050 if (!SWIG_IsOK(ecode2)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16052 }
16053 arg2 = static_cast< bool >(val2);
16054 }
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 result = (arg1)->Mirror(arg2);
16058 wxPyEndAllowThreads(__tstate);
16059 if (PyErr_Occurred()) SWIG_fail;
16060 }
16061 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16069 PyObject *resultobj = 0;
16070 wxImage *arg1 = (wxImage *) 0 ;
16071 byte arg2 ;
16072 byte arg3 ;
16073 byte arg4 ;
16074 byte arg5 ;
16075 byte arg6 ;
16076 byte arg7 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 unsigned char val2 ;
16080 int ecode2 = 0 ;
16081 unsigned char val3 ;
16082 int ecode3 = 0 ;
16083 unsigned char val4 ;
16084 int ecode4 = 0 ;
16085 unsigned char val5 ;
16086 int ecode5 = 0 ;
16087 unsigned char val6 ;
16088 int ecode6 = 0 ;
16089 unsigned char val7 ;
16090 int ecode7 = 0 ;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 PyObject * obj2 = 0 ;
16094 PyObject * obj3 = 0 ;
16095 PyObject * obj4 = 0 ;
16096 PyObject * obj5 = 0 ;
16097 PyObject * obj6 = 0 ;
16098 char * kwnames[] = {
16099 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16100 };
16101
16102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16106 }
16107 arg1 = reinterpret_cast< wxImage * >(argp1);
16108 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16109 if (!SWIG_IsOK(ecode2)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16111 }
16112 arg2 = static_cast< byte >(val2);
16113 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16114 if (!SWIG_IsOK(ecode3)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16116 }
16117 arg3 = static_cast< byte >(val3);
16118 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16119 if (!SWIG_IsOK(ecode4)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16121 }
16122 arg4 = static_cast< byte >(val4);
16123 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16124 if (!SWIG_IsOK(ecode5)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16126 }
16127 arg5 = static_cast< byte >(val5);
16128 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16129 if (!SWIG_IsOK(ecode6)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16131 }
16132 arg6 = static_cast< byte >(val6);
16133 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16134 if (!SWIG_IsOK(ecode7)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16136 }
16137 arg7 = static_cast< byte >(val7);
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_Py_Void();
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 double arg2 = (double) 0.299 ;
16155 double arg3 = (double) 0.587 ;
16156 double arg4 = (double) 0.114 ;
16157 SwigValueWrapper<wxImage > result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 double val2 ;
16161 int ecode2 = 0 ;
16162 double val3 ;
16163 int ecode3 = 0 ;
16164 double val4 ;
16165 int ecode4 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 PyObject * obj3 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 if (obj1) {
16181 ecode2 = SWIG_AsVal_double(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16184 }
16185 arg2 = static_cast< double >(val2);
16186 }
16187 if (obj2) {
16188 ecode3 = SWIG_AsVal_double(obj2, &val3);
16189 if (!SWIG_IsOK(ecode3)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16191 }
16192 arg3 = static_cast< double >(val3);
16193 }
16194 if (obj3) {
16195 ecode4 = SWIG_AsVal_double(obj3, &val4);
16196 if (!SWIG_IsOK(ecode4)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16198 }
16199 arg4 = static_cast< double >(val4);
16200 }
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj = 0;
16216 wxImage *arg1 = (wxImage *) 0 ;
16217 byte arg2 ;
16218 byte arg3 ;
16219 byte arg4 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 unsigned char val2 ;
16224 int ecode2 = 0 ;
16225 unsigned char val3 ;
16226 int ecode3 = 0 ;
16227 unsigned char val4 ;
16228 int ecode4 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 PyObject * obj3 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16246 }
16247 arg2 = static_cast< byte >(val2);
16248 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16251 }
16252 arg3 = static_cast< byte >(val3);
16253 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16254 if (!SWIG_IsOK(ecode4)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16256 }
16257 arg4 = static_cast< byte >(val4);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 wxString *arg2 = 0 ;
16275 wxString *arg3 = 0 ;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 bool temp2 = false ;
16279 bool temp3 = false ;
16280 PyObject * obj0 = 0 ;
16281 PyObject * obj1 = 0 ;
16282 PyObject * obj2 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *) "name",(char *) "value", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16291 }
16292 arg1 = reinterpret_cast< wxImage * >(argp1);
16293 {
16294 arg2 = wxString_in_helper(obj1);
16295 if (arg2 == NULL) SWIG_fail;
16296 temp2 = true;
16297 }
16298 {
16299 arg3 = wxString_in_helper(obj2);
16300 if (arg3 == NULL) SWIG_fail;
16301 temp3 = true;
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_Py_Void();
16310 {
16311 if (temp2)
16312 delete arg2;
16313 }
16314 {
16315 if (temp3)
16316 delete arg3;
16317 }
16318 return resultobj;
16319 fail:
16320 {
16321 if (temp2)
16322 delete arg2;
16323 }
16324 {
16325 if (temp3)
16326 delete arg3;
16327 }
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxImage *arg1 = (wxImage *) 0 ;
16335 wxString *arg2 = 0 ;
16336 int arg3 ;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 bool temp2 = false ;
16340 int val3 ;
16341 int ecode3 = 0 ;
16342 PyObject * obj0 = 0 ;
16343 PyObject * obj1 = 0 ;
16344 PyObject * obj2 = 0 ;
16345 char * kwnames[] = {
16346 (char *) "self",(char *) "name",(char *) "value", NULL
16347 };
16348
16349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16353 }
16354 arg1 = reinterpret_cast< wxImage * >(argp1);
16355 {
16356 arg2 = wxString_in_helper(obj1);
16357 if (arg2 == NULL) SWIG_fail;
16358 temp2 = true;
16359 }
16360 ecode3 = SWIG_AsVal_int(obj2, &val3);
16361 if (!SWIG_IsOK(ecode3)) {
16362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16363 }
16364 arg3 = static_cast< int >(val3);
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetOption((wxString const &)*arg2,arg3);
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 resultobj = SWIG_Py_Void();
16372 {
16373 if (temp2)
16374 delete arg2;
16375 }
16376 return resultobj;
16377 fail:
16378 {
16379 if (temp2)
16380 delete arg2;
16381 }
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxImage *arg1 = (wxImage *) 0 ;
16389 wxString *arg2 = 0 ;
16390 wxString result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 bool temp2 = false ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "name", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16404 }
16405 arg1 = reinterpret_cast< wxImage * >(argp1);
16406 {
16407 arg2 = wxString_in_helper(obj1);
16408 if (arg2 == NULL) SWIG_fail;
16409 temp2 = true;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 #if wxUSE_UNICODE
16419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16420 #else
16421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16422 #endif
16423 }
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxImage *arg1 = (wxImage *) 0 ;
16441 wxString *arg2 = 0 ;
16442 int result;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 bool temp2 = false ;
16446 PyObject * obj0 = 0 ;
16447 PyObject * obj1 = 0 ;
16448 char * kwnames[] = {
16449 (char *) "self",(char *) "name", NULL
16450 };
16451
16452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16456 }
16457 arg1 = reinterpret_cast< wxImage * >(argp1);
16458 {
16459 arg2 = wxString_in_helper(obj1);
16460 if (arg2 == NULL) SWIG_fail;
16461 temp2 = true;
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16466 wxPyEndAllowThreads(__tstate);
16467 if (PyErr_Occurred()) SWIG_fail;
16468 }
16469 resultobj = SWIG_From_int(static_cast< int >(result));
16470 {
16471 if (temp2)
16472 delete arg2;
16473 }
16474 return resultobj;
16475 fail:
16476 {
16477 if (temp2)
16478 delete arg2;
16479 }
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxImage *arg1 = (wxImage *) 0 ;
16487 wxString *arg2 = 0 ;
16488 bool result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 bool temp2 = false ;
16492 PyObject * obj0 = 0 ;
16493 PyObject * obj1 = 0 ;
16494 char * kwnames[] = {
16495 (char *) "self",(char *) "name", NULL
16496 };
16497
16498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16502 }
16503 arg1 = reinterpret_cast< wxImage * >(argp1);
16504 {
16505 arg2 = wxString_in_helper(obj1);
16506 if (arg2 == NULL) SWIG_fail;
16507 temp2 = true;
16508 }
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16517 }
16518 {
16519 if (temp2)
16520 delete arg2;
16521 }
16522 return resultobj;
16523 fail:
16524 {
16525 if (temp2)
16526 delete arg2;
16527 }
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImage *arg1 = (wxImage *) 0 ;
16535 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16536 unsigned long result;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 unsigned long val2 ;
16540 int ecode2 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "stopafter", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 if (obj1) {
16554 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16557 }
16558 arg2 = static_cast< unsigned long >(val2);
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 result = (unsigned long)(arg1)->CountColours(arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxImageHistogram *arg2 = 0 ;
16577 unsigned long result;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 void *argp2 = 0 ;
16581 int res2 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "h", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16595 if (!SWIG_IsOK(res2)) {
16596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16597 }
16598 if (!argp2) {
16599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16600 }
16601 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj = 0;
16617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16618 void *argp1 = 0 ;
16619 int res1 = 0 ;
16620 PyObject * obj0 = 0 ;
16621 char * kwnames[] = {
16622 (char *) "handler", NULL
16623 };
16624
16625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16627 if (!SWIG_IsOK(res1)) {
16628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16629 }
16630 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 wxImage::AddHandler(arg1);
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 resultobj = SWIG_Py_Void();
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = 0;
16646 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 PyObject * obj0 = 0 ;
16650 char * kwnames[] = {
16651 (char *) "handler", NULL
16652 };
16653
16654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16658 }
16659 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 wxImage::InsertHandler(arg1);
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_Py_Void();
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj = 0;
16675 wxString *arg1 = 0 ;
16676 bool result;
16677 bool temp1 = false ;
16678 PyObject * obj0 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "name", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16684 {
16685 arg1 = wxString_in_helper(obj0);
16686 if (arg1 == NULL) SWIG_fail;
16687 temp1 = true;
16688 }
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 {
16696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16697 }
16698 {
16699 if (temp1)
16700 delete arg1;
16701 }
16702 return resultobj;
16703 fail:
16704 {
16705 if (temp1)
16706 delete arg1;
16707 }
16708 return NULL;
16709 }
16710
16711
16712 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16713 PyObject *resultobj = 0;
16714 PyObject *result = 0 ;
16715
16716 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (PyObject *)wxImage_GetHandlers();
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = result;
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731 PyObject *resultobj = 0;
16732 wxString result;
16733
16734 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = wxImage::GetImageExtWildcard();
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 #if wxUSE_UNICODE
16743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16744 #else
16745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16746 #endif
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj = 0;
16756 wxImage *arg1 = (wxImage *) 0 ;
16757 int arg2 = (int) -1 ;
16758 wxBitmap result;
16759 void *argp1 = 0 ;
16760 int res1 = 0 ;
16761 int val2 ;
16762 int ecode2 = 0 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 char * kwnames[] = {
16766 (char *) "self",(char *) "depth", NULL
16767 };
16768
16769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16771 if (!SWIG_IsOK(res1)) {
16772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16773 }
16774 arg1 = reinterpret_cast< wxImage * >(argp1);
16775 if (obj1) {
16776 ecode2 = SWIG_AsVal_int(obj1, &val2);
16777 if (!SWIG_IsOK(ecode2)) {
16778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16779 }
16780 arg2 = static_cast< int >(val2);
16781 }
16782 {
16783 if (!wxPyCheckForApp()) SWIG_fail;
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = wxImage_ConvertToBitmap(arg1,arg2);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 byte arg2 ;
16800 byte arg3 ;
16801 byte arg4 ;
16802 wxBitmap result;
16803 void *argp1 = 0 ;
16804 int res1 = 0 ;
16805 unsigned char val2 ;
16806 int ecode2 = 0 ;
16807 unsigned char val3 ;
16808 int ecode3 = 0 ;
16809 unsigned char val4 ;
16810 int ecode4 = 0 ;
16811 PyObject * obj0 = 0 ;
16812 PyObject * obj1 = 0 ;
16813 PyObject * obj2 = 0 ;
16814 PyObject * obj3 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16823 }
16824 arg1 = reinterpret_cast< wxImage * >(argp1);
16825 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16828 }
16829 arg2 = static_cast< byte >(val2);
16830 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16831 if (!SWIG_IsOK(ecode3)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16833 }
16834 arg3 = static_cast< byte >(val3);
16835 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16836 if (!SWIG_IsOK(ecode4)) {
16837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16838 }
16839 arg4 = static_cast< byte >(val4);
16840 {
16841 if (!wxPyCheckForApp()) SWIG_fail;
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj = 0;
16856 wxImage *arg1 = (wxImage *) 0 ;
16857 double arg2 ;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 double val2 ;
16861 int ecode2 = 0 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "angle", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16872 }
16873 arg1 = reinterpret_cast< wxImage * >(argp1);
16874 ecode2 = SWIG_AsVal_double(obj1, &val2);
16875 if (!SWIG_IsOK(ecode2)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16877 }
16878 arg2 = static_cast< double >(val2);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 (arg1)->RotateHue(arg2);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_Py_Void();
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxImage_RGBValue arg1 ;
16895 wxImage_HSVValue result;
16896 void *argp1 ;
16897 int res1 = 0 ;
16898 PyObject * obj0 = 0 ;
16899 char * kwnames[] = {
16900 (char *) "rgb", NULL
16901 };
16902
16903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16904 {
16905 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16908 }
16909 if (!argp1) {
16910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16911 } else {
16912 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16913 arg1 = *temp;
16914 if (SWIG_IsNewObj(res1)) delete temp;
16915 }
16916 }
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 result = wxImage::RGBtoHSV(arg1);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj = 0;
16932 wxImage_HSVValue arg1 ;
16933 wxImage_RGBValue result;
16934 void *argp1 ;
16935 int res1 = 0 ;
16936 PyObject * obj0 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "hsv", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16942 {
16943 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16946 }
16947 if (!argp1) {
16948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16949 } else {
16950 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16951 arg1 = *temp;
16952 if (SWIG_IsNewObj(res1)) delete temp;
16953 }
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = wxImage::HSVtoRGB(arg1);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16969 PyObject *obj;
16970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16971 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16972 return SWIG_Py_Void();
16973 }
16974
16975 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16976 return SWIG_Python_InitShadowInstance(args);
16977 }
16978
16979 SWIGINTERN int NullImage_set(PyObject *) {
16980 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16981 return 1;
16982 }
16983
16984
16985 SWIGINTERN PyObject *NullImage_get(void) {
16986 PyObject *pyobj = 0;
16987
16988 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16989 return pyobj;
16990 }
16991
16992
16993 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16995 return 1;
16996 }
16997
16998
16999 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17000 PyObject *pyobj = 0;
17001
17002 {
17003 #if wxUSE_UNICODE
17004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17005 #else
17006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17007 #endif
17008 }
17009 return pyobj;
17010 }
17011
17012
17013 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17015 return 1;
17016 }
17017
17018
17019 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17020 PyObject *pyobj = 0;
17021
17022 {
17023 #if wxUSE_UNICODE
17024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17025 #else
17026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17027 #endif
17028 }
17029 return pyobj;
17030 }
17031
17032
17033 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17035 return 1;
17036 }
17037
17038
17039 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17040 PyObject *pyobj = 0;
17041
17042 {
17043 #if wxUSE_UNICODE
17044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17045 #else
17046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17047 #endif
17048 }
17049 return pyobj;
17050 }
17051
17052
17053 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17055 return 1;
17056 }
17057
17058
17059 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17060 PyObject *pyobj = 0;
17061
17062 {
17063 #if wxUSE_UNICODE
17064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17065 #else
17066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17067 #endif
17068 }
17069 return pyobj;
17070 }
17071
17072
17073 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17075 return 1;
17076 }
17077
17078
17079 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17080 PyObject *pyobj = 0;
17081
17082 {
17083 #if wxUSE_UNICODE
17084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17085 #else
17086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17087 #endif
17088 }
17089 return pyobj;
17090 }
17091
17092
17093 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17095 return 1;
17096 }
17097
17098
17099 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17100 PyObject *pyobj = 0;
17101
17102 {
17103 #if wxUSE_UNICODE
17104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17105 #else
17106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17107 #endif
17108 }
17109 return pyobj;
17110 }
17111
17112
17113 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17114 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17115 return 1;
17116 }
17117
17118
17119 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17120 PyObject *pyobj = 0;
17121
17122 {
17123 #if wxUSE_UNICODE
17124 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17125 #else
17126 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17127 #endif
17128 }
17129 return pyobj;
17130 }
17131
17132
17133 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17134 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17135 return 1;
17136 }
17137
17138
17139 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17140 PyObject *pyobj = 0;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17154 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17155 return 1;
17156 }
17157
17158
17159 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17160 PyObject *pyobj = 0;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17174 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17175 return 1;
17176 }
17177
17178
17179 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17180 PyObject *pyobj = 0;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17194 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17195 return 1;
17196 }
17197
17198
17199 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17200 PyObject *pyobj = 0;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17214 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17215 return 1;
17216 }
17217
17218
17219 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17220 PyObject *pyobj = 0;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17234 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17235 return 1;
17236 }
17237
17238
17239 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17240 PyObject *pyobj = 0;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17254 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17255 return 1;
17256 }
17257
17258
17259 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17260 PyObject *pyobj = 0;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17274 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17275 return 1;
17276 }
17277
17278
17279 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17280 PyObject *pyobj = 0;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 PyObject *resultobj = 0;
17295 wxBMPHandler *result = 0 ;
17296
17297 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (wxBMPHandler *)new wxBMPHandler();
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17312 PyObject *obj;
17313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17314 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17315 return SWIG_Py_Void();
17316 }
17317
17318 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 return SWIG_Python_InitShadowInstance(args);
17320 }
17321
17322 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 wxICOHandler *result = 0 ;
17325
17326 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (wxICOHandler *)new wxICOHandler();
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17341 PyObject *obj;
17342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17343 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17344 return SWIG_Py_Void();
17345 }
17346
17347 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 return SWIG_Python_InitShadowInstance(args);
17349 }
17350
17351 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 PyObject *resultobj = 0;
17353 wxCURHandler *result = 0 ;
17354
17355 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (wxCURHandler *)new wxCURHandler();
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17370 PyObject *obj;
17371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17372 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17373 return SWIG_Py_Void();
17374 }
17375
17376 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 return SWIG_Python_InitShadowInstance(args);
17378 }
17379
17380 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 PyObject *resultobj = 0;
17382 wxANIHandler *result = 0 ;
17383
17384 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (wxANIHandler *)new wxANIHandler();
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17399 PyObject *obj;
17400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17401 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17402 return SWIG_Py_Void();
17403 }
17404
17405 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17406 return SWIG_Python_InitShadowInstance(args);
17407 }
17408
17409 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 PyObject *resultobj = 0;
17411 wxPNGHandler *result = 0 ;
17412
17413 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17414 {
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (wxPNGHandler *)new wxPNGHandler();
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17421 return resultobj;
17422 fail:
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 PyObject *obj;
17429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17430 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17431 return SWIG_Py_Void();
17432 }
17433
17434 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17435 return SWIG_Python_InitShadowInstance(args);
17436 }
17437
17438 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *resultobj = 0;
17440 wxGIFHandler *result = 0 ;
17441
17442 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (wxGIFHandler *)new wxGIFHandler();
17446 wxPyEndAllowThreads(__tstate);
17447 if (PyErr_Occurred()) SWIG_fail;
17448 }
17449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17450 return resultobj;
17451 fail:
17452 return NULL;
17453 }
17454
17455
17456 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17457 PyObject *obj;
17458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17459 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17460 return SWIG_Py_Void();
17461 }
17462
17463 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 return SWIG_Python_InitShadowInstance(args);
17465 }
17466
17467 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *resultobj = 0;
17469 wxPCXHandler *result = 0 ;
17470
17471 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (wxPCXHandler *)new wxPCXHandler();
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *obj;
17487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17488 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17489 return SWIG_Py_Void();
17490 }
17491
17492 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 return SWIG_Python_InitShadowInstance(args);
17494 }
17495
17496 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 PyObject *resultobj = 0;
17498 wxJPEGHandler *result = 0 ;
17499
17500 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxJPEGHandler *)new wxJPEGHandler();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *obj;
17516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17517 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17518 return SWIG_Py_Void();
17519 }
17520
17521 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 return SWIG_Python_InitShadowInstance(args);
17523 }
17524
17525 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxPNMHandler *result = 0 ;
17528
17529 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxPNMHandler *)new wxPNMHandler();
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17544 PyObject *obj;
17545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17547 return SWIG_Py_Void();
17548 }
17549
17550 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 return SWIG_Python_InitShadowInstance(args);
17552 }
17553
17554 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *resultobj = 0;
17556 wxXPMHandler *result = 0 ;
17557
17558 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 result = (wxXPMHandler *)new wxXPMHandler();
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *obj;
17574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17575 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17576 return SWIG_Py_Void();
17577 }
17578
17579 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 return SWIG_Python_InitShadowInstance(args);
17581 }
17582
17583 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17584 PyObject *resultobj = 0;
17585 wxTIFFHandler *result = 0 ;
17586
17587 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxTIFFHandler *)new wxTIFFHandler();
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *obj;
17603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17604 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17605 return SWIG_Py_Void();
17606 }
17607
17608 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 return SWIG_Python_InitShadowInstance(args);
17610 }
17611
17612 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj = 0;
17614 wxImage *arg1 = 0 ;
17615 wxImage *arg2 = 0 ;
17616 int arg3 = (int) 236 ;
17617 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17618 bool result;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 void *argp2 = 0 ;
17622 int res2 = 0 ;
17623 int val3 ;
17624 int ecode3 = 0 ;
17625 int val4 ;
17626 int ecode4 = 0 ;
17627 PyObject * obj0 = 0 ;
17628 PyObject * obj1 = 0 ;
17629 PyObject * obj2 = 0 ;
17630 PyObject * obj3 = 0 ;
17631 char * kwnames[] = {
17632 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17633 };
17634
17635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17636 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17637 if (!SWIG_IsOK(res1)) {
17638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17639 }
17640 if (!argp1) {
17641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17642 }
17643 arg1 = reinterpret_cast< wxImage * >(argp1);
17644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17645 if (!SWIG_IsOK(res2)) {
17646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17647 }
17648 if (!argp2) {
17649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17650 }
17651 arg2 = reinterpret_cast< wxImage * >(argp2);
17652 if (obj2) {
17653 ecode3 = SWIG_AsVal_int(obj2, &val3);
17654 if (!SWIG_IsOK(ecode3)) {
17655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17656 }
17657 arg3 = static_cast< int >(val3);
17658 }
17659 if (obj3) {
17660 ecode4 = SWIG_AsVal_int(obj3, &val4);
17661 if (!SWIG_IsOK(ecode4)) {
17662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17663 }
17664 arg4 = static_cast< int >(val4);
17665 }
17666 {
17667 PyThreadState* __tstate = wxPyBeginAllowThreads();
17668 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17682 PyObject *obj;
17683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17684 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17685 return SWIG_Py_Void();
17686 }
17687
17688 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *result = 0 ;
17691
17692 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxEvtHandler *)new wxEvtHandler();
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17700 return resultobj;
17701 fail:
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17709 wxEvtHandler *result = 0 ;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 PyObject *swig_obj[1] ;
17713
17714 if (!args) SWIG_fail;
17715 swig_obj[0] = args;
17716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17717 if (!SWIG_IsOK(res1)) {
17718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17719 }
17720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 {
17728 resultobj = wxPyMake_wxObject(result, 0);
17729 }
17730 return resultobj;
17731 fail:
17732 return NULL;
17733 }
17734
17735
17736 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17739 wxEvtHandler *result = 0 ;
17740 void *argp1 = 0 ;
17741 int res1 = 0 ;
17742 PyObject *swig_obj[1] ;
17743
17744 if (!args) SWIG_fail;
17745 swig_obj[0] = args;
17746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17747 if (!SWIG_IsOK(res1)) {
17748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17749 }
17750 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 resultobj = wxPyMake_wxObject(result, 0);
17759 }
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj = 0;
17768 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17769 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 void *argp2 = 0 ;
17773 int res2 = 0 ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "handler", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17784 }
17785 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17787 if (!SWIG_IsOK(res2)) {
17788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17789 }
17790 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 (arg1)->SetNextHandler(arg2);
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 resultobj = SWIG_Py_Void();
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj = 0;
17806 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17807 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 void *argp2 = 0 ;
17811 int res2 = 0 ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "handler", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17822 }
17823 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17825 if (!SWIG_IsOK(res2)) {
17826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17827 }
17828 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 (arg1)->SetPreviousHandler(arg2);
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_Py_Void();
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 bool result;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17855 }
17856 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)(arg1)->GetEvtHandlerEnabled();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 {
17864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj = 0;
17874 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17875 bool arg2 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 bool val2 ;
17879 int ecode2 = 0 ;
17880 PyObject * obj0 = 0 ;
17881 PyObject * obj1 = 0 ;
17882 char * kwnames[] = {
17883 (char *) "self",(char *) "enabled", NULL
17884 };
17885
17886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17890 }
17891 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17893 if (!SWIG_IsOK(ecode2)) {
17894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17895 }
17896 arg2 = static_cast< bool >(val2);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->SetEvtHandlerEnabled(arg2);
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 wxEvent *arg2 = 0 ;
17914 bool result;
17915 void *argp1 = 0 ;
17916 int res1 = 0 ;
17917 void *argp2 = 0 ;
17918 int res2 = 0 ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 char * kwnames[] = {
17922 (char *) "self",(char *) "event", NULL
17923 };
17924
17925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17932 if (!SWIG_IsOK(res2)) {
17933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17934 }
17935 if (!argp2) {
17936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17937 }
17938 arg2 = reinterpret_cast< wxEvent * >(argp2);
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 result = (bool)(arg1)->ProcessEvent(*arg2);
17942 wxPyEndAllowThreads(__tstate);
17943 if (PyErr_Occurred()) SWIG_fail;
17944 }
17945 {
17946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17947 }
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj = 0;
17956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17957 wxEvent *arg2 = 0 ;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 void *argp2 = 0 ;
17961 int res2 = 0 ;
17962 PyObject * obj0 = 0 ;
17963 PyObject * obj1 = 0 ;
17964 char * kwnames[] = {
17965 (char *) "self",(char *) "event", NULL
17966 };
17967
17968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17970 if (!SWIG_IsOK(res1)) {
17971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17972 }
17973 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17975 if (!SWIG_IsOK(res2)) {
17976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17977 }
17978 if (!argp2) {
17979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17980 }
17981 arg2 = reinterpret_cast< wxEvent * >(argp2);
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 (arg1)->AddPendingEvent(*arg2);
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_Py_Void();
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *resultobj = 0;
17997 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject *swig_obj[1] ;
18001
18002 if (!args) SWIG_fail;
18003 swig_obj[0] = args;
18004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18007 }
18008 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 (arg1)->ProcessPendingEvents();
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_Py_Void();
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj = 0;
18024 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18025 int arg2 ;
18026 int arg3 ;
18027 int arg4 ;
18028 PyObject *arg5 = (PyObject *) 0 ;
18029 void *argp1 = 0 ;
18030 int res1 = 0 ;
18031 int val2 ;
18032 int ecode2 = 0 ;
18033 int val3 ;
18034 int ecode3 = 0 ;
18035 int val4 ;
18036 int ecode4 = 0 ;
18037 PyObject * obj0 = 0 ;
18038 PyObject * obj1 = 0 ;
18039 PyObject * obj2 = 0 ;
18040 PyObject * obj3 = 0 ;
18041 PyObject * obj4 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18050 }
18051 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18052 ecode2 = SWIG_AsVal_int(obj1, &val2);
18053 if (!SWIG_IsOK(ecode2)) {
18054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18055 }
18056 arg2 = static_cast< int >(val2);
18057 ecode3 = SWIG_AsVal_int(obj2, &val3);
18058 if (!SWIG_IsOK(ecode3)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18060 }
18061 arg3 = static_cast< int >(val3);
18062 ecode4 = SWIG_AsVal_int(obj3, &val4);
18063 if (!SWIG_IsOK(ecode4)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18065 }
18066 arg4 = static_cast< int >(val4);
18067 arg5 = obj4;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 resultobj = SWIG_Py_Void();
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18084 int arg2 ;
18085 int arg3 = (int) -1 ;
18086 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18087 bool result;
18088 void *argp1 = 0 ;
18089 int res1 = 0 ;
18090 int val2 ;
18091 int ecode2 = 0 ;
18092 int val3 ;
18093 int ecode3 = 0 ;
18094 int val4 ;
18095 int ecode4 = 0 ;
18096 PyObject * obj0 = 0 ;
18097 PyObject * obj1 = 0 ;
18098 PyObject * obj2 = 0 ;
18099 PyObject * obj3 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18108 }
18109 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18110 ecode2 = SWIG_AsVal_int(obj1, &val2);
18111 if (!SWIG_IsOK(ecode2)) {
18112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18113 }
18114 arg2 = static_cast< int >(val2);
18115 if (obj2) {
18116 ecode3 = SWIG_AsVal_int(obj2, &val3);
18117 if (!SWIG_IsOK(ecode3)) {
18118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18119 }
18120 arg3 = static_cast< int >(val3);
18121 }
18122 if (obj3) {
18123 ecode4 = SWIG_AsVal_int(obj3, &val4);
18124 if (!SWIG_IsOK(ecode4)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18126 }
18127 arg4 = static_cast< wxEventType >(val4);
18128 }
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj = 0;
18146 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18147 PyObject *arg2 = (PyObject *) 0 ;
18148 bool arg3 = (bool) true ;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 bool val3 ;
18152 int ecode3 = 0 ;
18153 PyObject * obj0 = 0 ;
18154 PyObject * obj1 = 0 ;
18155 PyObject * obj2 = 0 ;
18156 char * kwnames[] = {
18157 (char *) "self",(char *) "_self",(char *) "incref", NULL
18158 };
18159
18160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18162 if (!SWIG_IsOK(res1)) {
18163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18164 }
18165 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18166 arg2 = obj1;
18167 if (obj2) {
18168 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18169 if (!SWIG_IsOK(ecode3)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18171 }
18172 arg3 = static_cast< bool >(val3);
18173 }
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = SWIG_Py_Void();
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 PyObject *obj;
18189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18190 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18191 return SWIG_Py_Void();
18192 }
18193
18194 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18195 return SWIG_Python_InitShadowInstance(args);
18196 }
18197
18198 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxEventType result;
18201
18202 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (wxEventType)wxNewEventType();
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 resultobj = SWIG_From_int(static_cast< int >(result));
18210 return resultobj;
18211 fail:
18212 return NULL;
18213 }
18214
18215
18216 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18217 PyObject *resultobj = 0;
18218 wxEvent *arg1 = (wxEvent *) 0 ;
18219 void *argp1 = 0 ;
18220 int res1 = 0 ;
18221 PyObject *swig_obj[1] ;
18222
18223 if (!args) SWIG_fail;
18224 swig_obj[0] = args;
18225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 delete arg1;
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 resultobj = SWIG_Py_Void();
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj = 0;
18246 wxEvent *arg1 = (wxEvent *) 0 ;
18247 wxEventType arg2 ;
18248 void *argp1 = 0 ;
18249 int res1 = 0 ;
18250 int val2 ;
18251 int ecode2 = 0 ;
18252 PyObject * obj0 = 0 ;
18253 PyObject * obj1 = 0 ;
18254 char * kwnames[] = {
18255 (char *) "self",(char *) "typ", NULL
18256 };
18257
18258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18260 if (!SWIG_IsOK(res1)) {
18261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18262 }
18263 arg1 = reinterpret_cast< wxEvent * >(argp1);
18264 ecode2 = SWIG_AsVal_int(obj1, &val2);
18265 if (!SWIG_IsOK(ecode2)) {
18266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18267 }
18268 arg2 = static_cast< wxEventType >(val2);
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 (arg1)->SetEventType(arg2);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_Py_Void();
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxEvent *arg1 = (wxEvent *) 0 ;
18285 wxEventType result;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = SWIG_From_int(static_cast< int >(result));
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18311 PyObject *resultobj = 0;
18312 wxEvent *arg1 = (wxEvent *) 0 ;
18313 wxObject *result = 0 ;
18314 void *argp1 = 0 ;
18315 int res1 = 0 ;
18316 PyObject *swig_obj[1] ;
18317
18318 if (!args) SWIG_fail;
18319 swig_obj[0] = args;
18320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18321 if (!SWIG_IsOK(res1)) {
18322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18323 }
18324 arg1 = reinterpret_cast< wxEvent * >(argp1);
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 resultobj = wxPyMake_wxObject(result, (bool)0);
18333 }
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj = 0;
18342 wxEvent *arg1 = (wxEvent *) 0 ;
18343 wxObject *arg2 = (wxObject *) 0 ;
18344 void *argp1 = 0 ;
18345 int res1 = 0 ;
18346 void *argp2 = 0 ;
18347 int res2 = 0 ;
18348 PyObject * obj0 = 0 ;
18349 PyObject * obj1 = 0 ;
18350 char * kwnames[] = {
18351 (char *) "self",(char *) "obj", NULL
18352 };
18353
18354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18356 if (!SWIG_IsOK(res1)) {
18357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18358 }
18359 arg1 = reinterpret_cast< wxEvent * >(argp1);
18360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18361 if (!SWIG_IsOK(res2)) {
18362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18363 }
18364 arg2 = reinterpret_cast< wxObject * >(argp2);
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 (arg1)->SetEventObject(arg2);
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 resultobj = SWIG_Py_Void();
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18379 PyObject *resultobj = 0;
18380 wxEvent *arg1 = (wxEvent *) 0 ;
18381 long result;
18382 void *argp1 = 0 ;
18383 int res1 = 0 ;
18384 PyObject *swig_obj[1] ;
18385
18386 if (!args) SWIG_fail;
18387 swig_obj[0] = args;
18388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18389 if (!SWIG_IsOK(res1)) {
18390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18391 }
18392 arg1 = reinterpret_cast< wxEvent * >(argp1);
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_From_long(static_cast< long >(result));
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj = 0;
18408 wxEvent *arg1 = (wxEvent *) 0 ;
18409 long arg2 = (long) 0 ;
18410 void *argp1 = 0 ;
18411 int res1 = 0 ;
18412 long val2 ;
18413 int ecode2 = 0 ;
18414 PyObject * obj0 = 0 ;
18415 PyObject * obj1 = 0 ;
18416 char * kwnames[] = {
18417 (char *) "self",(char *) "ts", NULL
18418 };
18419
18420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18424 }
18425 arg1 = reinterpret_cast< wxEvent * >(argp1);
18426 if (obj1) {
18427 ecode2 = SWIG_AsVal_long(obj1, &val2);
18428 if (!SWIG_IsOK(ecode2)) {
18429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18430 }
18431 arg2 = static_cast< long >(val2);
18432 }
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 (arg1)->SetTimestamp(arg2);
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 resultobj = SWIG_Py_Void();
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18447 PyObject *resultobj = 0;
18448 wxEvent *arg1 = (wxEvent *) 0 ;
18449 int result;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 PyObject *swig_obj[1] ;
18453
18454 if (!args) SWIG_fail;
18455 swig_obj[0] = args;
18456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (int)((wxEvent const *)arg1)->GetId();
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_From_int(static_cast< int >(result));
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj = 0;
18476 wxEvent *arg1 = (wxEvent *) 0 ;
18477 int arg2 ;
18478 void *argp1 = 0 ;
18479 int res1 = 0 ;
18480 int val2 ;
18481 int ecode2 = 0 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 char * kwnames[] = {
18485 (char *) "self",(char *) "Id", NULL
18486 };
18487
18488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 ecode2 = SWIG_AsVal_int(obj1, &val2);
18495 if (!SWIG_IsOK(ecode2)) {
18496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18497 }
18498 arg2 = static_cast< int >(val2);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 (arg1)->SetId(arg2);
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_Py_Void();
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 bool result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 {
18534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18535 }
18536 return resultobj;
18537 fail:
18538 return NULL;
18539 }
18540
18541
18542 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj = 0;
18544 wxEvent *arg1 = (wxEvent *) 0 ;
18545 bool arg2 = (bool) true ;
18546 void *argp1 = 0 ;
18547 int res1 = 0 ;
18548 bool val2 ;
18549 int ecode2 = 0 ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "self",(char *) "skip", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18560 }
18561 arg1 = reinterpret_cast< wxEvent * >(argp1);
18562 if (obj1) {
18563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18564 if (!SWIG_IsOK(ecode2)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18566 }
18567 arg2 = static_cast< bool >(val2);
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 (arg1)->Skip(arg2);
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 resultobj = SWIG_Py_Void();
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18583 PyObject *resultobj = 0;
18584 wxEvent *arg1 = (wxEvent *) 0 ;
18585 bool result;
18586 void *argp1 = 0 ;
18587 int res1 = 0 ;
18588 PyObject *swig_obj[1] ;
18589
18590 if (!args) SWIG_fail;
18591 swig_obj[0] = args;
18592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18593 if (!SWIG_IsOK(res1)) {
18594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18595 }
18596 arg1 = reinterpret_cast< wxEvent * >(argp1);
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 {
18604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18605 }
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18613 PyObject *resultobj = 0;
18614 wxEvent *arg1 = (wxEvent *) 0 ;
18615 bool result;
18616 void *argp1 = 0 ;
18617 int res1 = 0 ;
18618 PyObject *swig_obj[1] ;
18619
18620 if (!args) SWIG_fail;
18621 swig_obj[0] = args;
18622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvent * >(argp1);
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18643 PyObject *resultobj = 0;
18644 wxEvent *arg1 = (wxEvent *) 0 ;
18645 int result;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18655 }
18656 arg1 = reinterpret_cast< wxEvent * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (int)(arg1)->StopPropagation();
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 resultobj = SWIG_From_int(static_cast< int >(result));
18664 return resultobj;
18665 fail:
18666 return NULL;
18667 }
18668
18669
18670 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18671 PyObject *resultobj = 0;
18672 wxEvent *arg1 = (wxEvent *) 0 ;
18673 int arg2 ;
18674 void *argp1 = 0 ;
18675 int res1 = 0 ;
18676 int val2 ;
18677 int ecode2 = 0 ;
18678 PyObject * obj0 = 0 ;
18679 PyObject * obj1 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "propagationLevel", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvent * >(argp1);
18690 ecode2 = SWIG_AsVal_int(obj1, &val2);
18691 if (!SWIG_IsOK(ecode2)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18693 }
18694 arg2 = static_cast< int >(val2);
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 (arg1)->ResumePropagation(arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_Py_Void();
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxEvent *arg1 = (wxEvent *) 0 ;
18711 wxEvent *result = 0 ;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxEvent *)(arg1)->Clone();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *obj;
18738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18739 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18740 return SWIG_Py_Void();
18741 }
18742
18743 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj = 0;
18745 wxEvent *arg1 = 0 ;
18746 wxPropagationDisabler *result = 0 ;
18747 void *argp1 = 0 ;
18748 int res1 = 0 ;
18749 PyObject * obj0 = 0 ;
18750 char * kwnames[] = {
18751 (char *) "event", NULL
18752 };
18753
18754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18755 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18756 if (!SWIG_IsOK(res1)) {
18757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18758 }
18759 if (!argp1) {
18760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18761 }
18762 arg1 = reinterpret_cast< wxEvent * >(argp1);
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 PyObject *resultobj = 0;
18778 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18779 void *argp1 = 0 ;
18780 int res1 = 0 ;
18781 PyObject *swig_obj[1] ;
18782
18783 if (!args) SWIG_fail;
18784 swig_obj[0] = args;
18785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18786 if (!SWIG_IsOK(res1)) {
18787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18788 }
18789 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 delete arg1;
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 resultobj = SWIG_Py_Void();
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18805 PyObject *obj;
18806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18807 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18808 return SWIG_Py_Void();
18809 }
18810
18811 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18812 return SWIG_Python_InitShadowInstance(args);
18813 }
18814
18815 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj = 0;
18817 wxEvent *arg1 = 0 ;
18818 wxPropagateOnce *result = 0 ;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject * obj0 = 0 ;
18822 char * kwnames[] = {
18823 (char *) "event", NULL
18824 };
18825
18826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18827 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18830 }
18831 if (!argp1) {
18832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18833 }
18834 arg1 = reinterpret_cast< wxEvent * >(argp1);
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 PyObject *resultobj = 0;
18850 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 PyObject *swig_obj[1] ;
18854
18855 if (!args) SWIG_fail;
18856 swig_obj[0] = args;
18857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18860 }
18861 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 delete arg1;
18865
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 resultobj = SWIG_Py_Void();
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 SWIGINTERN PyObject *PropagateOnce_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_wxPropagateOnce, SWIG_NewClientData(obj));
18880 return SWIG_Py_Void();
18881 }
18882
18883 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18884 return SWIG_Python_InitShadowInstance(args);
18885 }
18886
18887 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj = 0;
18889 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18890 int arg2 = (int) 0 ;
18891 wxCommandEvent *result = 0 ;
18892 int val1 ;
18893 int ecode1 = 0 ;
18894 int val2 ;
18895 int ecode2 = 0 ;
18896 PyObject * obj0 = 0 ;
18897 PyObject * obj1 = 0 ;
18898 char * kwnames[] = {
18899 (char *) "commandType",(char *) "winid", NULL
18900 };
18901
18902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18903 if (obj0) {
18904 ecode1 = SWIG_AsVal_int(obj0, &val1);
18905 if (!SWIG_IsOK(ecode1)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18907 }
18908 arg1 = static_cast< wxEventType >(val1);
18909 }
18910 if (obj1) {
18911 ecode2 = SWIG_AsVal_int(obj1, &val2);
18912 if (!SWIG_IsOK(ecode2)) {
18913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18914 }
18915 arg2 = static_cast< int >(val2);
18916 }
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 int result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_From_int(static_cast< int >(result));
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj = 0;
18960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18961 wxString *arg2 = 0 ;
18962 void *argp1 = 0 ;
18963 int res1 = 0 ;
18964 bool temp2 = false ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char * kwnames[] = {
18968 (char *) "self",(char *) "s", NULL
18969 };
18970
18971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18973 if (!SWIG_IsOK(res1)) {
18974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18975 }
18976 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18977 {
18978 arg2 = wxString_in_helper(obj1);
18979 if (arg2 == NULL) SWIG_fail;
18980 temp2 = true;
18981 }
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 (arg1)->SetString((wxString const &)*arg2);
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = SWIG_Py_Void();
18989 {
18990 if (temp2)
18991 delete arg2;
18992 }
18993 return resultobj;
18994 fail:
18995 {
18996 if (temp2)
18997 delete arg2;
18998 }
18999 return NULL;
19000 }
19001
19002
19003 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19004 PyObject *resultobj = 0;
19005 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19006 wxString result;
19007 void *argp1 = 0 ;
19008 int res1 = 0 ;
19009 PyObject *swig_obj[1] ;
19010
19011 if (!args) SWIG_fail;
19012 swig_obj[0] = args;
19013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = ((wxCommandEvent const *)arg1)->GetString();
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 {
19025 #if wxUSE_UNICODE
19026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19027 #else
19028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19029 #endif
19030 }
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19038 PyObject *resultobj = 0;
19039 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19040 bool result;
19041 void *argp1 = 0 ;
19042 int res1 = 0 ;
19043 PyObject *swig_obj[1] ;
19044
19045 if (!args) SWIG_fail;
19046 swig_obj[0] = args;
19047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19050 }
19051 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19055 wxPyEndAllowThreads(__tstate);
19056 if (PyErr_Occurred()) SWIG_fail;
19057 }
19058 {
19059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19060 }
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19070 bool result;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19080 }
19081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 return resultobj;
19092 fail:
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19100 long arg2 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 long val2 ;
19104 int ecode2 = 0 ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "extraLong", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",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_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19115 }
19116 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19117 ecode2 = SWIG_AsVal_long(obj1, &val2);
19118 if (!SWIG_IsOK(ecode2)) {
19119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19120 }
19121 arg2 = static_cast< long >(val2);
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->SetExtraLong(arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_Py_Void();
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 PyObject *resultobj = 0;
19137 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19138 long result;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19148 }
19149 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 resultobj = SWIG_From_long(static_cast< long >(result));
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj = 0;
19165 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19166 int arg2 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 int val2 ;
19170 int ecode2 = 0 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char * kwnames[] = {
19174 (char *) "self",(char *) "i", NULL
19175 };
19176
19177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19181 }
19182 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19183 ecode2 = SWIG_AsVal_int(obj1, &val2);
19184 if (!SWIG_IsOK(ecode2)) {
19185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19186 }
19187 arg2 = static_cast< int >(val2);
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 (arg1)->SetInt(arg2);
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 resultobj = SWIG_Py_Void();
19195 return resultobj;
19196 fail:
19197 return NULL;
19198 }
19199
19200
19201 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19202 PyObject *resultobj = 0;
19203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19204 int result;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19214 }
19215 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 resultobj = SWIG_From_int(static_cast< int >(result));
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 PyObject *resultobj = 0;
19231 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19232 PyObject *result = 0 ;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 PyObject *swig_obj[1] ;
19236
19237 if (!args) SWIG_fail;
19238 swig_obj[0] = args;
19239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19242 }
19243 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = result;
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19260 PyObject *arg2 = (PyObject *) 0 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char * kwnames[] = {
19266 (char *) "self",(char *) "clientData", NULL
19267 };
19268
19269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19271 if (!SWIG_IsOK(res1)) {
19272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19273 }
19274 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19275 arg2 = obj1;
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 wxCommandEvent_SetClientData(arg1,arg2);
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 resultobj = SWIG_Py_Void();
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19290 PyObject *resultobj = 0;
19291 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19292 wxEvent *result = 0 ;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 PyObject *swig_obj[1] ;
19296
19297 if (!args) SWIG_fail;
19298 swig_obj[0] = args;
19299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19302 }
19303 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *obj;
19319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19320 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19321 return SWIG_Py_Void();
19322 }
19323
19324 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 return SWIG_Python_InitShadowInstance(args);
19326 }
19327
19328 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj = 0;
19330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19331 int arg2 = (int) 0 ;
19332 wxNotifyEvent *result = 0 ;
19333 int val1 ;
19334 int ecode1 = 0 ;
19335 int val2 ;
19336 int ecode2 = 0 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "commandType",(char *) "winid", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19344 if (obj0) {
19345 ecode1 = SWIG_AsVal_int(obj0, &val1);
19346 if (!SWIG_IsOK(ecode1)) {
19347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19348 }
19349 arg1 = static_cast< wxEventType >(val1);
19350 }
19351 if (obj1) {
19352 ecode2 = SWIG_AsVal_int(obj1, &val2);
19353 if (!SWIG_IsOK(ecode2)) {
19354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19355 }
19356 arg2 = static_cast< int >(val2);
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19372 PyObject *resultobj = 0;
19373 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 PyObject *swig_obj[1] ;
19377
19378 if (!args) SWIG_fail;
19379 swig_obj[0] = args;
19380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19381 if (!SWIG_IsOK(res1)) {
19382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19383 }
19384 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->Veto();
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19410 }
19411 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 (arg1)->Allow();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_Py_Void();
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19428 bool result;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (bool)(arg1)->IsAllowed();
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 {
19447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19448 }
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19456 PyObject *obj;
19457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19458 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19459 return SWIG_Py_Void();
19460 }
19461
19462 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19463 return SWIG_Python_InitShadowInstance(args);
19464 }
19465
19466 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj = 0;
19468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19469 int arg2 = (int) 0 ;
19470 int arg3 = (int) 0 ;
19471 int arg4 = (int) 0 ;
19472 wxScrollEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 int val3 ;
19478 int ecode3 = 0 ;
19479 int val4 ;
19480 int ecode4 = 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 PyObject * obj2 = 0 ;
19484 PyObject * obj3 = 0 ;
19485 char * kwnames[] = {
19486 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19487 };
19488
19489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19490 if (obj0) {
19491 ecode1 = SWIG_AsVal_int(obj0, &val1);
19492 if (!SWIG_IsOK(ecode1)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19494 }
19495 arg1 = static_cast< wxEventType >(val1);
19496 }
19497 if (obj1) {
19498 ecode2 = SWIG_AsVal_int(obj1, &val2);
19499 if (!SWIG_IsOK(ecode2)) {
19500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19501 }
19502 arg2 = static_cast< int >(val2);
19503 }
19504 if (obj2) {
19505 ecode3 = SWIG_AsVal_int(obj2, &val3);
19506 if (!SWIG_IsOK(ecode3)) {
19507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19508 }
19509 arg3 = static_cast< int >(val3);
19510 }
19511 if (obj3) {
19512 ecode4 = SWIG_AsVal_int(obj3, &val4);
19513 if (!SWIG_IsOK(ecode4)) {
19514 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19515 }
19516 arg4 = static_cast< int >(val4);
19517 }
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19532 PyObject *resultobj = 0;
19533 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19534 int result;
19535 void *argp1 = 0 ;
19536 int res1 = 0 ;
19537 PyObject *swig_obj[1] ;
19538
19539 if (!args) SWIG_fail;
19540 swig_obj[0] = args;
19541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19542 if (!SWIG_IsOK(res1)) {
19543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19544 }
19545 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 resultobj = SWIG_From_int(static_cast< int >(result));
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 PyObject *resultobj = 0;
19561 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19562 int result;
19563 void *argp1 = 0 ;
19564 int res1 = 0 ;
19565 PyObject *swig_obj[1] ;
19566
19567 if (!args) SWIG_fail;
19568 swig_obj[0] = args;
19569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19572 }
19573 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 resultobj = SWIG_From_int(static_cast< int >(result));
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = 0;
19589 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19590 int arg2 ;
19591 void *argp1 = 0 ;
19592 int res1 = 0 ;
19593 int val2 ;
19594 int ecode2 = 0 ;
19595 PyObject * obj0 = 0 ;
19596 PyObject * obj1 = 0 ;
19597 char * kwnames[] = {
19598 (char *) "self",(char *) "orient", NULL
19599 };
19600
19601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19603 if (!SWIG_IsOK(res1)) {
19604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19605 }
19606 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19607 ecode2 = SWIG_AsVal_int(obj1, &val2);
19608 if (!SWIG_IsOK(ecode2)) {
19609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19610 }
19611 arg2 = static_cast< int >(val2);
19612 {
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 (arg1)->SetOrientation(arg2);
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_Py_Void();
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = 0;
19627 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19628 int arg2 ;
19629 void *argp1 = 0 ;
19630 int res1 = 0 ;
19631 int val2 ;
19632 int ecode2 = 0 ;
19633 PyObject * obj0 = 0 ;
19634 PyObject * obj1 = 0 ;
19635 char * kwnames[] = {
19636 (char *) "self",(char *) "pos", NULL
19637 };
19638
19639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19643 }
19644 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19645 ecode2 = SWIG_AsVal_int(obj1, &val2);
19646 if (!SWIG_IsOK(ecode2)) {
19647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19648 }
19649 arg2 = static_cast< int >(val2);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 (arg1)->SetPosition(arg2);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_Py_Void();
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19664 PyObject *obj;
19665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19666 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19667 return SWIG_Py_Void();
19668 }
19669
19670 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 return SWIG_Python_InitShadowInstance(args);
19672 }
19673
19674 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj = 0;
19676 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19677 int arg2 = (int) 0 ;
19678 int arg3 = (int) 0 ;
19679 wxScrollWinEvent *result = 0 ;
19680 int val1 ;
19681 int ecode1 = 0 ;
19682 int val2 ;
19683 int ecode2 = 0 ;
19684 int val3 ;
19685 int ecode3 = 0 ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 PyObject * obj2 = 0 ;
19689 char * kwnames[] = {
19690 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19691 };
19692
19693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19694 if (obj0) {
19695 ecode1 = SWIG_AsVal_int(obj0, &val1);
19696 if (!SWIG_IsOK(ecode1)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19698 }
19699 arg1 = static_cast< wxEventType >(val1);
19700 }
19701 if (obj1) {
19702 ecode2 = SWIG_AsVal_int(obj1, &val2);
19703 if (!SWIG_IsOK(ecode2)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19705 }
19706 arg2 = static_cast< int >(val2);
19707 }
19708 if (obj2) {
19709 ecode3 = SWIG_AsVal_int(obj2, &val3);
19710 if (!SWIG_IsOK(ecode3)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19712 }
19713 arg3 = static_cast< int >(val3);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 wxMouseEvent *result = 0 ;
19875 int val1 ;
19876 int ecode1 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 char * kwnames[] = {
19879 (char *) "mouseType", NULL
19880 };
19881
19882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19883 if (obj0) {
19884 ecode1 = SWIG_AsVal_int(obj0, &val1);
19885 if (!SWIG_IsOK(ecode1)) {
19886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19887 }
19888 arg1 = static_cast< wxEventType >(val1);
19889 }
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 {
19897 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19898 }
19899 return resultobj;
19900 fail:
19901 return NULL;
19902 }
19903
19904
19905 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19906 PyObject *resultobj = 0;
19907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19908 bool result;
19909 void *argp1 = 0 ;
19910 int res1 = 0 ;
19911 PyObject *swig_obj[1] ;
19912
19913 if (!args) SWIG_fail;
19914 swig_obj[0] = args;
19915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19918 }
19919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 {
19927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19928 }
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = 0;
19937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19938 int arg2 = (int) wxMOUSE_BTN_ANY ;
19939 bool result;
19940 void *argp1 = 0 ;
19941 int res1 = 0 ;
19942 int val2 ;
19943 int ecode2 = 0 ;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 char * kwnames[] = {
19947 (char *) "self",(char *) "but", NULL
19948 };
19949
19950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 if (obj1) {
19957 ecode2 = SWIG_AsVal_int(obj1, &val2);
19958 if (!SWIG_IsOK(ecode2)) {
19959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19960 }
19961 arg2 = static_cast< int >(val2);
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 {
19970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19971 }
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19979 PyObject *resultobj = 0;
19980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19981 int arg2 = (int) wxMOUSE_BTN_ANY ;
19982 bool result;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 int val2 ;
19986 int ecode2 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char * kwnames[] = {
19990 (char *) "self",(char *) "but", NULL
19991 };
19992
19993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19997 }
19998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19999 if (obj1) {
20000 ecode2 = SWIG_AsVal_int(obj1, &val2);
20001 if (!SWIG_IsOK(ecode2)) {
20002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20003 }
20004 arg2 = static_cast< int >(val2);
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 {
20013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20014 }
20015 return resultobj;
20016 fail:
20017 return NULL;
20018 }
20019
20020
20021 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20022 PyObject *resultobj = 0;
20023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20024 int arg2 = (int) wxMOUSE_BTN_ANY ;
20025 bool result;
20026 void *argp1 = 0 ;
20027 int res1 = 0 ;
20028 int val2 ;
20029 int ecode2 = 0 ;
20030 PyObject * obj0 = 0 ;
20031 PyObject * obj1 = 0 ;
20032 char * kwnames[] = {
20033 (char *) "self",(char *) "but", NULL
20034 };
20035
20036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 if (obj1) {
20043 ecode2 = SWIG_AsVal_int(obj1, &val2);
20044 if (!SWIG_IsOK(ecode2)) {
20045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20046 }
20047 arg2 = static_cast< int >(val2);
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 {
20056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20057 }
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj = 0;
20066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20067 int arg2 ;
20068 bool result;
20069 void *argp1 = 0 ;
20070 int res1 = 0 ;
20071 int val2 ;
20072 int ecode2 = 0 ;
20073 PyObject * obj0 = 0 ;
20074 PyObject * obj1 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "self",(char *) "button", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20081 if (!SWIG_IsOK(res1)) {
20082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20083 }
20084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20085 ecode2 = SWIG_AsVal_int(obj1, &val2);
20086 if (!SWIG_IsOK(ecode2)) {
20087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20088 }
20089 arg2 = static_cast< int >(val2);
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 {
20097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20098 }
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj = 0;
20107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20108 int arg2 ;
20109 bool result;
20110 void *argp1 = 0 ;
20111 int res1 = 0 ;
20112 int val2 ;
20113 int ecode2 = 0 ;
20114 PyObject * obj0 = 0 ;
20115 PyObject * obj1 = 0 ;
20116 char * kwnames[] = {
20117 (char *) "self",(char *) "but", NULL
20118 };
20119
20120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20122 if (!SWIG_IsOK(res1)) {
20123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20124 }
20125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20126 ecode2 = SWIG_AsVal_int(obj1, &val2);
20127 if (!SWIG_IsOK(ecode2)) {
20128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20129 }
20130 arg2 = static_cast< int >(val2);
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 {
20138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20139 }
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20149 int result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20159 }
20160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_From_int(static_cast< int >(result));
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *resultobj = 0;
20176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20177 bool result;
20178 void *argp1 = 0 ;
20179 int res1 = 0 ;
20180 PyObject *swig_obj[1] ;
20181
20182 if (!args) SWIG_fail;
20183 swig_obj[0] = args;
20184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20187 }
20188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
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_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *resultobj = 0;
20206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 PyObject *swig_obj[1] ;
20211
20212 if (!args) SWIG_fail;
20213 swig_obj[0] = args;
20214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20217 }
20218 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 {
20226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20227 }
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *resultobj = 0;
20236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20237 bool result;
20238 void *argp1 = 0 ;
20239 int res1 = 0 ;
20240 PyObject *swig_obj[1] ;
20241
20242 if (!args) SWIG_fail;
20243 swig_obj[0] = args;
20244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20245 if (!SWIG_IsOK(res1)) {
20246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20247 }
20248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20265 PyObject *resultobj = 0;
20266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20267 bool result;
20268 void *argp1 = 0 ;
20269 int res1 = 0 ;
20270 PyObject *swig_obj[1] ;
20271
20272 if (!args) SWIG_fail;
20273 swig_obj[0] = args;
20274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20277 }
20278 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 {
20286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20287 }
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 PyObject *resultobj = 0;
20296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20297 bool result;
20298 void *argp1 = 0 ;
20299 int res1 = 0 ;
20300 PyObject *swig_obj[1] ;
20301
20302 if (!args) SWIG_fail;
20303 swig_obj[0] = args;
20304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20307 }
20308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20317 }
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 PyObject *resultobj = 0;
20326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20327 bool result;
20328 void *argp1 = 0 ;
20329 int res1 = 0 ;
20330 PyObject *swig_obj[1] ;
20331
20332 if (!args) SWIG_fail;
20333 swig_obj[0] = args;
20334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20335 if (!SWIG_IsOK(res1)) {
20336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20337 }
20338 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20347 }
20348 return resultobj;
20349 fail:
20350 return NULL;
20351 }
20352
20353
20354 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 PyObject *resultobj = 0;
20356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20357 bool result;
20358 void *argp1 = 0 ;
20359 int res1 = 0 ;
20360 PyObject *swig_obj[1] ;
20361
20362 if (!args) SWIG_fail;
20363 swig_obj[0] = args;
20364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20365 if (!SWIG_IsOK(res1)) {
20366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20367 }
20368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20385 PyObject *resultobj = 0;
20386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20387 bool result;
20388 void *argp1 = 0 ;
20389 int res1 = 0 ;
20390 PyObject *swig_obj[1] ;
20391
20392 if (!args) SWIG_fail;
20393 swig_obj[0] = args;
20394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20395 if (!SWIG_IsOK(res1)) {
20396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20397 }
20398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 PyObject *resultobj = 0;
20416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20417 bool result;
20418 void *argp1 = 0 ;
20419 int res1 = 0 ;
20420 PyObject *swig_obj[1] ;
20421
20422 if (!args) SWIG_fail;
20423 swig_obj[0] = args;
20424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20427 }
20428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 {
20436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20437 }
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 PyObject *resultobj = 0;
20446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20447 bool result;
20448 void *argp1 = 0 ;
20449 int res1 = 0 ;
20450 PyObject *swig_obj[1] ;
20451
20452 if (!args) SWIG_fail;
20453 swig_obj[0] = args;
20454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20455 if (!SWIG_IsOK(res1)) {
20456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20457 }
20458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20462 wxPyEndAllowThreads(__tstate);
20463 if (PyErr_Occurred()) SWIG_fail;
20464 }
20465 {
20466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20467 }
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 PyObject *resultobj = 0;
20476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20477 bool result;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20487 }
20488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20492 wxPyEndAllowThreads(__tstate);
20493 if (PyErr_Occurred()) SWIG_fail;
20494 }
20495 {
20496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20505 PyObject *resultobj = 0;
20506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20507 bool result;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject *swig_obj[1] ;
20511
20512 if (!args) SWIG_fail;
20513 swig_obj[0] = args;
20514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20515 if (!SWIG_IsOK(res1)) {
20516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20517 }
20518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20527 }
20528 return resultobj;
20529 fail:
20530 return NULL;
20531 }
20532
20533
20534 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20535 PyObject *resultobj = 0;
20536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20537 bool result;
20538 void *argp1 = 0 ;
20539 int res1 = 0 ;
20540 PyObject *swig_obj[1] ;
20541
20542 if (!args) SWIG_fail;
20543 swig_obj[0] = args;
20544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20545 if (!SWIG_IsOK(res1)) {
20546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20547 }
20548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 {
20556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20565 PyObject *resultobj = 0;
20566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20567 bool result;
20568 void *argp1 = 0 ;
20569 int res1 = 0 ;
20570 PyObject *swig_obj[1] ;
20571
20572 if (!args) SWIG_fail;
20573 swig_obj[0] = args;
20574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20575 if (!SWIG_IsOK(res1)) {
20576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20577 }
20578 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 {
20586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20587 }
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20595 PyObject *resultobj = 0;
20596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20597 bool result;
20598 void *argp1 = 0 ;
20599 int res1 = 0 ;
20600 PyObject *swig_obj[1] ;
20601
20602 if (!args) SWIG_fail;
20603 swig_obj[0] = args;
20604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20605 if (!SWIG_IsOK(res1)) {
20606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20607 }
20608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (bool)(arg1)->LeftIsDown();
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 {
20616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20617 }
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 PyObject *resultobj = 0;
20626 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20627 bool result;
20628 void *argp1 = 0 ;
20629 int res1 = 0 ;
20630 PyObject *swig_obj[1] ;
20631
20632 if (!args) SWIG_fail;
20633 swig_obj[0] = args;
20634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20635 if (!SWIG_IsOK(res1)) {
20636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20637 }
20638 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20639 {
20640 PyThreadState* __tstate = wxPyBeginAllowThreads();
20641 result = (bool)(arg1)->MiddleIsDown();
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20647 }
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655 PyObject *resultobj = 0;
20656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20657 bool result;
20658 void *argp1 = 0 ;
20659 int res1 = 0 ;
20660 PyObject *swig_obj[1] ;
20661
20662 if (!args) SWIG_fail;
20663 swig_obj[0] = args;
20664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20665 if (!SWIG_IsOK(res1)) {
20666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20667 }
20668 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = (bool)(arg1)->RightIsDown();
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 {
20676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20677 }
20678 return resultobj;
20679 fail:
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685 PyObject *resultobj = 0;
20686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20687 bool result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 PyObject *swig_obj[1] ;
20691
20692 if (!args) SWIG_fail;
20693 swig_obj[0] = args;
20694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20695 if (!SWIG_IsOK(res1)) {
20696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20697 }
20698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 bool result;
20718 void *argp1 = 0 ;
20719 int res1 = 0 ;
20720 PyObject *swig_obj[1] ;
20721
20722 if (!args) SWIG_fail;
20723 swig_obj[0] = args;
20724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20725 if (!SWIG_IsOK(res1)) {
20726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20727 }
20728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 PyObject *resultobj = 0;
20746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20747 bool result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 PyObject *swig_obj[1] ;
20751
20752 if (!args) SWIG_fail;
20753 swig_obj[0] = args;
20754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20757 }
20758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 {
20766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20767 }
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20775 PyObject *resultobj = 0;
20776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20777 bool result;
20778 void *argp1 = 0 ;
20779 int res1 = 0 ;
20780 PyObject *swig_obj[1] ;
20781
20782 if (!args) SWIG_fail;
20783 swig_obj[0] = args;
20784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20787 }
20788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20789 {
20790 PyThreadState* __tstate = wxPyBeginAllowThreads();
20791 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20792 wxPyEndAllowThreads(__tstate);
20793 if (PyErr_Occurred()) SWIG_fail;
20794 }
20795 {
20796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805 PyObject *resultobj = 0;
20806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20807 wxPoint result;
20808 void *argp1 = 0 ;
20809 int res1 = 0 ;
20810 PyObject *swig_obj[1] ;
20811
20812 if (!args) SWIG_fail;
20813 swig_obj[0] = args;
20814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20815 if (!SWIG_IsOK(res1)) {
20816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20817 }
20818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (arg1)->GetPosition();
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 long *arg2 = (long *) 0 ;
20836 long *arg3 = (long *) 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 long temp2 ;
20840 int res2 = SWIG_TMPOBJ ;
20841 long temp3 ;
20842 int res3 = SWIG_TMPOBJ ;
20843 PyObject *swig_obj[1] ;
20844
20845 arg2 = &temp2;
20846 arg3 = &temp3;
20847 if (!args) SWIG_fail;
20848 swig_obj[0] = args;
20849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20850 if (!SWIG_IsOK(res1)) {
20851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20852 }
20853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 (arg1)->GetPosition(arg2,arg3);
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 resultobj = SWIG_Py_Void();
20861 if (SWIG_IsTmpObj(res2)) {
20862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20863 } else {
20864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20866 }
20867 if (SWIG_IsTmpObj(res3)) {
20868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20869 } else {
20870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20872 }
20873 return resultobj;
20874 fail:
20875 return NULL;
20876 }
20877
20878
20879 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20880 PyObject *resultobj = 0;
20881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20882 wxDC *arg2 = 0 ;
20883 wxPoint result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 void *argp2 = 0 ;
20887 int res2 = 0 ;
20888 PyObject * obj0 = 0 ;
20889 PyObject * obj1 = 0 ;
20890 char * kwnames[] = {
20891 (char *) "self",(char *) "dc", NULL
20892 };
20893
20894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20896 if (!SWIG_IsOK(res1)) {
20897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20898 }
20899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20901 if (!SWIG_IsOK(res2)) {
20902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20903 }
20904 if (!argp2) {
20905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20906 }
20907 arg2 = reinterpret_cast< wxDC * >(argp2);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20922 PyObject *resultobj = 0;
20923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20924 int result;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 PyObject *swig_obj[1] ;
20928
20929 if (!args) SWIG_fail;
20930 swig_obj[0] = args;
20931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20934 }
20935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (int)((wxMouseEvent const *)arg1)->GetX();
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_From_int(static_cast< int >(result));
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 int result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (int)((wxMouseEvent const *)arg1)->GetY();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 resultobj = SWIG_From_int(static_cast< int >(result));
20971 return resultobj;
20972 fail:
20973 return NULL;
20974 }
20975
20976
20977 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20978 PyObject *resultobj = 0;
20979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20980 int result;
20981 void *argp1 = 0 ;
20982 int res1 = 0 ;
20983 PyObject *swig_obj[1] ;
20984
20985 if (!args) SWIG_fail;
20986 swig_obj[0] = args;
20987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_From_int(static_cast< int >(result));
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21006 PyObject *resultobj = 0;
21007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21008 int result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 PyObject *swig_obj[1] ;
21012
21013 if (!args) SWIG_fail;
21014 swig_obj[0] = args;
21015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21018 }
21019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = SWIG_From_int(static_cast< int >(result));
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21036 int result;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 PyObject *swig_obj[1] ;
21040
21041 if (!args) SWIG_fail;
21042 swig_obj[0] = args;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21046 }
21047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = SWIG_From_int(static_cast< int >(result));
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 bool 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_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 {
21083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21084 }
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21092 PyObject *resultobj = 0;
21093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21094 int arg2 ;
21095 void *argp1 = 0 ;
21096 int res1 = 0 ;
21097 int val2 ;
21098 int ecode2 = 0 ;
21099 PyObject *swig_obj[2] ;
21100
21101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21105 }
21106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21108 if (!SWIG_IsOK(ecode2)) {
21109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21110 }
21111 arg2 = static_cast< int >(val2);
21112 if (arg1) (arg1)->m_x = arg2;
21113
21114 resultobj = SWIG_Py_Void();
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21122 PyObject *resultobj = 0;
21123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21124 int result;
21125 void *argp1 = 0 ;
21126 int res1 = 0 ;
21127 PyObject *swig_obj[1] ;
21128
21129 if (!args) SWIG_fail;
21130 swig_obj[0] = args;
21131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21134 }
21135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21136 result = (int) ((arg1)->m_x);
21137 resultobj = SWIG_From_int(static_cast< int >(result));
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21147 int arg2 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 int val2 ;
21151 int ecode2 = 0 ;
21152 PyObject *swig_obj[2] ;
21153
21154 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
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_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21161 if (!SWIG_IsOK(ecode2)) {
21162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21163 }
21164 arg2 = static_cast< int >(val2);
21165 if (arg1) (arg1)->m_y = arg2;
21166
21167 resultobj = SWIG_Py_Void();
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 result = (int) ((arg1)->m_y);
21190 resultobj = SWIG_From_int(static_cast< int >(result));
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21198 PyObject *resultobj = 0;
21199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21200 bool arg2 ;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 bool val2 ;
21204 int ecode2 = 0 ;
21205 PyObject *swig_obj[2] ;
21206
21207 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21214 if (!SWIG_IsOK(ecode2)) {
21215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21216 }
21217 arg2 = static_cast< bool >(val2);
21218 if (arg1) (arg1)->m_leftDown = arg2;
21219
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21240 }
21241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21242 result = (bool) ((arg1)->m_leftDown);
21243 {
21244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21245 }
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21253 PyObject *resultobj = 0;
21254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21255 bool arg2 ;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 bool val2 ;
21259 int ecode2 = 0 ;
21260 PyObject *swig_obj[2] ;
21261
21262 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21264 if (!SWIG_IsOK(res1)) {
21265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21266 }
21267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21268 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21269 if (!SWIG_IsOK(ecode2)) {
21270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21271 }
21272 arg2 = static_cast< bool >(val2);
21273 if (arg1) (arg1)->m_middleDown = arg2;
21274
21275 resultobj = SWIG_Py_Void();
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21283 PyObject *resultobj = 0;
21284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21285 bool result;
21286 void *argp1 = 0 ;
21287 int res1 = 0 ;
21288 PyObject *swig_obj[1] ;
21289
21290 if (!args) SWIG_fail;
21291 swig_obj[0] = args;
21292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21295 }
21296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21297 result = (bool) ((arg1)->m_middleDown);
21298 {
21299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21300 }
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 PyObject *resultobj = 0;
21309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21310 bool arg2 ;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 bool val2 ;
21314 int ecode2 = 0 ;
21315 PyObject *swig_obj[2] ;
21316
21317 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21321 }
21322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21323 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21324 if (!SWIG_IsOK(ecode2)) {
21325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21326 }
21327 arg2 = static_cast< bool >(val2);
21328 if (arg1) (arg1)->m_rightDown = arg2;
21329
21330 resultobj = SWIG_Py_Void();
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21338 PyObject *resultobj = 0;
21339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21340 bool result;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 PyObject *swig_obj[1] ;
21344
21345 if (!args) SWIG_fail;
21346 swig_obj[0] = args;
21347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21350 }
21351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21352 result = (bool) ((arg1)->m_rightDown);
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21365 bool arg2 ;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 bool val2 ;
21369 int ecode2 = 0 ;
21370 PyObject *swig_obj[2] ;
21371
21372 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21374 if (!SWIG_IsOK(res1)) {
21375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21376 }
21377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21378 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21379 if (!SWIG_IsOK(ecode2)) {
21380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21381 }
21382 arg2 = static_cast< bool >(val2);
21383 if (arg1) (arg1)->m_controlDown = arg2;
21384
21385 resultobj = SWIG_Py_Void();
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool result;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 PyObject *swig_obj[1] ;
21399
21400 if (!args) SWIG_fail;
21401 swig_obj[0] = args;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 result = (bool) ((arg1)->m_controlDown);
21408 {
21409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21418 PyObject *resultobj = 0;
21419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21420 bool arg2 ;
21421 void *argp1 = 0 ;
21422 int res1 = 0 ;
21423 bool val2 ;
21424 int ecode2 = 0 ;
21425 PyObject *swig_obj[2] ;
21426
21427 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21429 if (!SWIG_IsOK(res1)) {
21430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21431 }
21432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21433 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21434 if (!SWIG_IsOK(ecode2)) {
21435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21436 }
21437 arg2 = static_cast< bool >(val2);
21438 if (arg1) (arg1)->m_shiftDown = arg2;
21439
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21460 }
21461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21462 result = (bool) ((arg1)->m_shiftDown);
21463 {
21464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21465 }
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21473 PyObject *resultobj = 0;
21474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21475 bool arg2 ;
21476 void *argp1 = 0 ;
21477 int res1 = 0 ;
21478 bool val2 ;
21479 int ecode2 = 0 ;
21480 PyObject *swig_obj[2] ;
21481
21482 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21484 if (!SWIG_IsOK(res1)) {
21485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21486 }
21487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21488 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21489 if (!SWIG_IsOK(ecode2)) {
21490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21491 }
21492 arg2 = static_cast< bool >(val2);
21493 if (arg1) (arg1)->m_altDown = arg2;
21494
21495 resultobj = SWIG_Py_Void();
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21505 bool result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 PyObject *swig_obj[1] ;
21509
21510 if (!args) SWIG_fail;
21511 swig_obj[0] = args;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21515 }
21516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21517 result = (bool) ((arg1)->m_altDown);
21518 {
21519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21528 PyObject *resultobj = 0;
21529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21530 bool arg2 ;
21531 void *argp1 = 0 ;
21532 int res1 = 0 ;
21533 bool val2 ;
21534 int ecode2 = 0 ;
21535 PyObject *swig_obj[2] ;
21536
21537 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21544 if (!SWIG_IsOK(ecode2)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21546 }
21547 arg2 = static_cast< bool >(val2);
21548 if (arg1) (arg1)->m_metaDown = arg2;
21549
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 result = (bool) ((arg1)->m_metaDown);
21573 {
21574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21575 }
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21583 PyObject *resultobj = 0;
21584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21585 int arg2 ;
21586 void *argp1 = 0 ;
21587 int res1 = 0 ;
21588 int val2 ;
21589 int ecode2 = 0 ;
21590 PyObject *swig_obj[2] ;
21591
21592 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21594 if (!SWIG_IsOK(res1)) {
21595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21596 }
21597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21598 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21599 if (!SWIG_IsOK(ecode2)) {
21600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21601 }
21602 arg2 = static_cast< int >(val2);
21603 if (arg1) (arg1)->m_wheelRotation = arg2;
21604
21605 resultobj = SWIG_Py_Void();
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *resultobj = 0;
21614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21615 int result;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 PyObject *swig_obj[1] ;
21619
21620 if (!args) SWIG_fail;
21621 swig_obj[0] = args;
21622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21625 }
21626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21627 result = (int) ((arg1)->m_wheelRotation);
21628 resultobj = SWIG_From_int(static_cast< int >(result));
21629 return resultobj;
21630 fail:
21631 return NULL;
21632 }
21633
21634
21635 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21636 PyObject *resultobj = 0;
21637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21638 int arg2 ;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 int val2 ;
21642 int ecode2 = 0 ;
21643 PyObject *swig_obj[2] ;
21644
21645 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21647 if (!SWIG_IsOK(res1)) {
21648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21649 }
21650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21652 if (!SWIG_IsOK(ecode2)) {
21653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21654 }
21655 arg2 = static_cast< int >(val2);
21656 if (arg1) (arg1)->m_wheelDelta = arg2;
21657
21658 resultobj = SWIG_Py_Void();
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21668 int result;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21678 }
21679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21680 result = (int) ((arg1)->m_wheelDelta);
21681 resultobj = SWIG_From_int(static_cast< int >(result));
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21691 int arg2 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 int val2 ;
21695 int ecode2 = 0 ;
21696 PyObject *swig_obj[2] ;
21697
21698 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21705 if (!SWIG_IsOK(ecode2)) {
21706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21707 }
21708 arg2 = static_cast< int >(val2);
21709 if (arg1) (arg1)->m_linesPerAction = arg2;
21710
21711 resultobj = SWIG_Py_Void();
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719 PyObject *resultobj = 0;
21720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21721 int result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 PyObject *swig_obj[1] ;
21725
21726 if (!args) SWIG_fail;
21727 swig_obj[0] = args;
21728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21731 }
21732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21733 result = (int) ((arg1)->m_linesPerAction);
21734 resultobj = SWIG_From_int(static_cast< int >(result));
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 int arg1 = (int) 0 ;
21755 int arg2 = (int) 0 ;
21756 wxSetCursorEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "x",(char *) "y", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21772 }
21773 arg1 = static_cast< int >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21824 PyObject *resultobj = 0;
21825 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21826 int result;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 PyObject *swig_obj[1] ;
21830
21831 if (!args) SWIG_fail;
21832 swig_obj[0] = args;
21833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21834 if (!SWIG_IsOK(res1)) {
21835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21836 }
21837 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 resultobj = SWIG_From_int(static_cast< int >(result));
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = 0;
21853 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21854 wxCursor *arg2 = 0 ;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 void *argp2 = 0 ;
21858 int res2 = 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "self",(char *) "cursor", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21867 if (!SWIG_IsOK(res1)) {
21868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21869 }
21870 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21871 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21872 if (!SWIG_IsOK(res2)) {
21873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21874 }
21875 if (!argp2) {
21876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21877 }
21878 arg2 = reinterpret_cast< wxCursor * >(argp2);
21879 {
21880 PyThreadState* __tstate = wxPyBeginAllowThreads();
21881 (arg1)->SetCursor((wxCursor const &)*arg2);
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 resultobj = SWIG_Py_Void();
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21893 PyObject *resultobj = 0;
21894 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21895 wxCursor *result = 0 ;
21896 void *argp1 = 0 ;
21897 int res1 = 0 ;
21898 PyObject *swig_obj[1] ;
21899
21900 if (!args) SWIG_fail;
21901 swig_obj[0] = args;
21902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21903 if (!SWIG_IsOK(res1)) {
21904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21905 }
21906 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 {
21910 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21911 result = (wxCursor *) &_result_ref;
21912 }
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 wxCursor* resultptr = new wxCursor(*result);
21918 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21927 PyObject *resultobj = 0;
21928 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21929 bool result;
21930 void *argp1 = 0 ;
21931 int res1 = 0 ;
21932 PyObject *swig_obj[1] ;
21933
21934 if (!args) SWIG_fail;
21935 swig_obj[0] = args;
21936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21939 }
21940 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21941 {
21942 PyThreadState* __tstate = wxPyBeginAllowThreads();
21943 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 {
21948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21949 }
21950 return resultobj;
21951 fail:
21952 return NULL;
21953 }
21954
21955
21956 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21957 PyObject *obj;
21958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21959 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21960 return SWIG_Py_Void();
21961 }
21962
21963 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21964 return SWIG_Python_InitShadowInstance(args);
21965 }
21966
21967 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = 0;
21969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21970 wxKeyEvent *result = 0 ;
21971 int val1 ;
21972 int ecode1 = 0 ;
21973 PyObject * obj0 = 0 ;
21974 char * kwnames[] = {
21975 (char *) "eventType", NULL
21976 };
21977
21978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21979 if (obj0) {
21980 ecode1 = SWIG_AsVal_int(obj0, &val1);
21981 if (!SWIG_IsOK(ecode1)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21983 }
21984 arg1 = static_cast< wxEventType >(val1);
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22002 int result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_From_int(static_cast< int >(result));
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22028 PyObject *resultobj = 0;
22029 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22030 bool result;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 PyObject *swig_obj[1] ;
22034
22035 if (!args) SWIG_fail;
22036 swig_obj[0] = args;
22037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22040 }
22041 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 {
22049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22050 }
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 PyObject *resultobj = 0;
22059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22060 bool result;
22061 void *argp1 = 0 ;
22062 int res1 = 0 ;
22063 PyObject *swig_obj[1] ;
22064
22065 if (!args) SWIG_fail;
22066 swig_obj[0] = args;
22067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22068 if (!SWIG_IsOK(res1)) {
22069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22070 }
22071 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 PyObject *resultobj = 0;
22089 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22090 bool result;
22091 void *argp1 = 0 ;
22092 int res1 = 0 ;
22093 PyObject *swig_obj[1] ;
22094
22095 if (!args) SWIG_fail;
22096 swig_obj[0] = args;
22097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22098 if (!SWIG_IsOK(res1)) {
22099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22100 }
22101 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22120 bool result;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 PyObject *swig_obj[1] ;
22124
22125 if (!args) SWIG_fail;
22126 swig_obj[0] = args;
22127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22130 }
22131 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 {
22139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22140 }
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22148 PyObject *resultobj = 0;
22149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22150 bool result;
22151 void *argp1 = 0 ;
22152 int res1 = 0 ;
22153 PyObject *swig_obj[1] ;
22154
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22178 PyObject *resultobj = 0;
22179 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22180 bool result;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject *swig_obj[1] ;
22184
22185 if (!args) SWIG_fail;
22186 swig_obj[0] = args;
22187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22188 if (!SWIG_IsOK(res1)) {
22189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22190 }
22191 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22210 int result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22220 }
22221 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_From_int(static_cast< int >(result));
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22238 int result;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_From_int(static_cast< int >(result));
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22266 int arg2 ;
22267 void *argp1 = 0 ;
22268 int res1 = 0 ;
22269 int val2 ;
22270 int ecode2 = 0 ;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char * kwnames[] = {
22274 (char *) "self",(char *) "uniChar", NULL
22275 };
22276
22277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22281 }
22282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22283 ecode2 = SWIG_AsVal_int(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22286 }
22287 arg2 = static_cast< int >(val2);
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 resultobj = SWIG_Py_Void();
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 PyObject *resultobj = 0;
22303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22304 unsigned int result;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22314 }
22315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 unsigned int result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22358 PyObject *resultobj = 0;
22359 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22360 wxPoint result;
22361 void *argp1 = 0 ;
22362 int res1 = 0 ;
22363 PyObject *swig_obj[1] ;
22364
22365 if (!args) SWIG_fail;
22366 swig_obj[0] = args;
22367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22368 if (!SWIG_IsOK(res1)) {
22369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22370 }
22371 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (arg1)->GetPosition();
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22386 PyObject *resultobj = 0;
22387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22388 long *arg2 = (long *) 0 ;
22389 long *arg3 = (long *) 0 ;
22390 void *argp1 = 0 ;
22391 int res1 = 0 ;
22392 long temp2 ;
22393 int res2 = SWIG_TMPOBJ ;
22394 long temp3 ;
22395 int res3 = SWIG_TMPOBJ ;
22396 PyObject *swig_obj[1] ;
22397
22398 arg2 = &temp2;
22399 arg3 = &temp3;
22400 if (!args) SWIG_fail;
22401 swig_obj[0] = args;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 (arg1)->GetPosition(arg2,arg3);
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = SWIG_Py_Void();
22414 if (SWIG_IsTmpObj(res2)) {
22415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22416 } else {
22417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22419 }
22420 if (SWIG_IsTmpObj(res3)) {
22421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22422 } else {
22423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)((wxKeyEvent const *)arg1)->GetX();
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = (int)((wxKeyEvent const *)arg1)->GetY();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_From_int(static_cast< int >(result));
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22491 int arg2 ;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 int val2 ;
22495 int ecode2 = 0 ;
22496 PyObject *swig_obj[2] ;
22497
22498 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22505 if (!SWIG_IsOK(ecode2)) {
22506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22507 }
22508 arg2 = static_cast< int >(val2);
22509 if (arg1) (arg1)->m_x = arg2;
22510
22511 resultobj = SWIG_Py_Void();
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22519 PyObject *resultobj = 0;
22520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22521 int result;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 PyObject *swig_obj[1] ;
22525
22526 if (!args) SWIG_fail;
22527 swig_obj[0] = args;
22528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22531 }
22532 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22533 result = (int) ((arg1)->m_x);
22534 resultobj = SWIG_From_int(static_cast< int >(result));
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22542 PyObject *resultobj = 0;
22543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22544 int arg2 ;
22545 void *argp1 = 0 ;
22546 int res1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 PyObject *swig_obj[2] ;
22550
22551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22555 }
22556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22557 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22558 if (!SWIG_IsOK(ecode2)) {
22559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22560 }
22561 arg2 = static_cast< int >(val2);
22562 if (arg1) (arg1)->m_y = arg2;
22563
22564 resultobj = SWIG_Py_Void();
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22572 PyObject *resultobj = 0;
22573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22574 int result;
22575 void *argp1 = 0 ;
22576 int res1 = 0 ;
22577 PyObject *swig_obj[1] ;
22578
22579 if (!args) SWIG_fail;
22580 swig_obj[0] = args;
22581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22584 }
22585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22586 result = (int) ((arg1)->m_y);
22587 resultobj = SWIG_From_int(static_cast< int >(result));
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22597 long arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 long val2 ;
22601 int ecode2 = 0 ;
22602 PyObject *swig_obj[2] ;
22603
22604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22613 }
22614 arg2 = static_cast< long >(val2);
22615 if (arg1) (arg1)->m_keyCode = arg2;
22616
22617 resultobj = SWIG_Py_Void();
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 long result;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 PyObject *swig_obj[1] ;
22631
22632 if (!args) SWIG_fail;
22633 swig_obj[0] = args;
22634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22639 result = (long) ((arg1)->m_keyCode);
22640 resultobj = SWIG_From_long(static_cast< long >(result));
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22650 bool arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 bool val2 ;
22654 int ecode2 = 0 ;
22655 PyObject *swig_obj[2] ;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22661 }
22662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22663 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22666 }
22667 arg2 = static_cast< bool >(val2);
22668 if (arg1) (arg1)->m_controlDown = arg2;
22669
22670 resultobj = SWIG_Py_Void();
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 bool result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22692 result = (bool) ((arg1)->m_controlDown);
22693 {
22694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22695 }
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22705 bool arg2 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 bool val2 ;
22709 int ecode2 = 0 ;
22710 PyObject *swig_obj[2] ;
22711
22712 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22716 }
22717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22718 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22719 if (!SWIG_IsOK(ecode2)) {
22720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22721 }
22722 arg2 = static_cast< bool >(val2);
22723 if (arg1) (arg1)->m_shiftDown = arg2;
22724
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 bool result;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 PyObject *swig_obj[1] ;
22739
22740 if (!args) SWIG_fail;
22741 swig_obj[0] = args;
22742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22745 }
22746 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22747 result = (bool) ((arg1)->m_shiftDown);
22748 {
22749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22758 PyObject *resultobj = 0;
22759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22760 bool arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 bool val2 ;
22764 int ecode2 = 0 ;
22765 PyObject *swig_obj[2] ;
22766
22767 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22771 }
22772 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22773 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22774 if (!SWIG_IsOK(ecode2)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22776 }
22777 arg2 = static_cast< bool >(val2);
22778 if (arg1) (arg1)->m_altDown = arg2;
22779
22780 resultobj = SWIG_Py_Void();
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 PyObject *resultobj = 0;
22789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22790 bool result;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 PyObject *swig_obj[1] ;
22794
22795 if (!args) SWIG_fail;
22796 swig_obj[0] = args;
22797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22798 if (!SWIG_IsOK(res1)) {
22799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22800 }
22801 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22802 result = (bool) ((arg1)->m_altDown);
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22813 PyObject *resultobj = 0;
22814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22815 bool arg2 ;
22816 void *argp1 = 0 ;
22817 int res1 = 0 ;
22818 bool val2 ;
22819 int ecode2 = 0 ;
22820 PyObject *swig_obj[2] ;
22821
22822 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22824 if (!SWIG_IsOK(res1)) {
22825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22826 }
22827 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22828 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22829 if (!SWIG_IsOK(ecode2)) {
22830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22831 }
22832 arg2 = static_cast< bool >(val2);
22833 if (arg1) (arg1)->m_metaDown = arg2;
22834
22835 resultobj = SWIG_Py_Void();
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22843 PyObject *resultobj = 0;
22844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 PyObject *swig_obj[1] ;
22849
22850 if (!args) SWIG_fail;
22851 swig_obj[0] = args;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22857 result = (bool) ((arg1)->m_metaDown);
22858 {
22859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22860 }
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22870 bool arg2 ;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 bool val2 ;
22874 int ecode2 = 0 ;
22875 PyObject *swig_obj[2] ;
22876
22877 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22881 }
22882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22883 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22884 if (!SWIG_IsOK(ecode2)) {
22885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22886 }
22887 arg2 = static_cast< bool >(val2);
22888 if (arg1) (arg1)->m_scanCode = arg2;
22889
22890 resultobj = SWIG_Py_Void();
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 result = (bool) ((arg1)->m_scanCode);
22913 {
22914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22915 }
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22925 unsigned int arg2 ;
22926 void *argp1 = 0 ;
22927 int res1 = 0 ;
22928 unsigned int val2 ;
22929 int ecode2 = 0 ;
22930 PyObject *swig_obj[2] ;
22931
22932 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22934 if (!SWIG_IsOK(res1)) {
22935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22936 }
22937 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22938 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22939 if (!SWIG_IsOK(ecode2)) {
22940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22941 }
22942 arg2 = static_cast< unsigned int >(val2);
22943 if (arg1) (arg1)->m_rawCode = arg2;
22944
22945 resultobj = SWIG_Py_Void();
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22953 PyObject *resultobj = 0;
22954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22955 unsigned int result;
22956 void *argp1 = 0 ;
22957 int res1 = 0 ;
22958 PyObject *swig_obj[1] ;
22959
22960 if (!args) SWIG_fail;
22961 swig_obj[0] = args;
22962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22963 if (!SWIG_IsOK(res1)) {
22964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22965 }
22966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22967 result = (unsigned int) ((arg1)->m_rawCode);
22968 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 PyObject *resultobj = 0;
22977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22978 unsigned int arg2 ;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 unsigned int val2 ;
22982 int ecode2 = 0 ;
22983 PyObject *swig_obj[2] ;
22984
22985 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22987 if (!SWIG_IsOK(res1)) {
22988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22989 }
22990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22991 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22992 if (!SWIG_IsOK(ecode2)) {
22993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22994 }
22995 arg2 = static_cast< unsigned int >(val2);
22996 if (arg1) (arg1)->m_rawFlags = arg2;
22997
22998 resultobj = SWIG_Py_Void();
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23006 PyObject *resultobj = 0;
23007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23008 unsigned int result;
23009 void *argp1 = 0 ;
23010 int res1 = 0 ;
23011 PyObject *swig_obj[1] ;
23012
23013 if (!args) SWIG_fail;
23014 swig_obj[0] = args;
23015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23016 if (!SWIG_IsOK(res1)) {
23017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23018 }
23019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23020 result = (unsigned int) ((arg1)->m_rawFlags);
23021 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23029 PyObject *obj;
23030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23031 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23032 return SWIG_Py_Void();
23033 }
23034
23035 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23036 return SWIG_Python_InitShadowInstance(args);
23037 }
23038
23039 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj = 0;
23041 wxSize const &arg1_defvalue = wxDefaultSize ;
23042 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23043 int arg2 = (int) 0 ;
23044 wxSizeEvent *result = 0 ;
23045 wxSize temp1 ;
23046 int val2 ;
23047 int ecode2 = 0 ;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "sz",(char *) "winid", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23055 if (obj0) {
23056 {
23057 arg1 = &temp1;
23058 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23059 }
23060 }
23061 if (obj1) {
23062 ecode2 = SWIG_AsVal_int(obj1, &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23065 }
23066 arg2 = static_cast< int >(val2);
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23084 wxSize result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = ((wxSizeEvent const *)arg1)->GetSize();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23112 wxRect result;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = ((wxSizeEvent const *)arg1)->GetRect();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj = 0;
23139 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23140 wxRect arg2 ;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 void *argp2 ;
23144 int res2 = 0 ;
23145 PyObject * obj0 = 0 ;
23146 PyObject * obj1 = 0 ;
23147 char * kwnames[] = {
23148 (char *) "self",(char *) "rect", NULL
23149 };
23150
23151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23153 if (!SWIG_IsOK(res1)) {
23154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23155 }
23156 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23157 {
23158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23159 if (!SWIG_IsOK(res2)) {
23160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23161 }
23162 if (!argp2) {
23163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23164 } else {
23165 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23166 arg2 = *temp;
23167 if (SWIG_IsNewObj(res2)) delete temp;
23168 }
23169 }
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 (arg1)->SetRect(arg2);
23173 wxPyEndAllowThreads(__tstate);
23174 if (PyErr_Occurred()) SWIG_fail;
23175 }
23176 resultobj = SWIG_Py_Void();
23177 return resultobj;
23178 fail:
23179 return NULL;
23180 }
23181
23182
23183 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23184 PyObject *resultobj = 0;
23185 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23186 wxSize arg2 ;
23187 void *argp1 = 0 ;
23188 int res1 = 0 ;
23189 void *argp2 ;
23190 int res2 = 0 ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "size", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23201 }
23202 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23203 {
23204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23205 if (!SWIG_IsOK(res2)) {
23206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23207 }
23208 if (!argp2) {
23209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23210 } else {
23211 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23212 arg2 = *temp;
23213 if (SWIG_IsNewObj(res2)) delete temp;
23214 }
23215 }
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 wxSizeEvent_SetSize(arg1,arg2);
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_Py_Void();
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23232 wxSize *arg2 = (wxSize *) 0 ;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 void *argp2 = 0 ;
23236 int res2 = 0 ;
23237 PyObject *swig_obj[2] ;
23238
23239 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23241 if (!SWIG_IsOK(res1)) {
23242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23243 }
23244 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23246 if (!SWIG_IsOK(res2)) {
23247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23248 }
23249 arg2 = reinterpret_cast< wxSize * >(argp2);
23250 if (arg1) (arg1)->m_size = *arg2;
23251
23252 resultobj = SWIG_Py_Void();
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23260 PyObject *resultobj = 0;
23261 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23262 wxSize *result = 0 ;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 PyObject *swig_obj[1] ;
23266
23267 if (!args) SWIG_fail;
23268 swig_obj[0] = args;
23269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23272 }
23273 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23274 result = (wxSize *)& ((arg1)->m_size);
23275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23283 PyObject *resultobj = 0;
23284 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23285 wxRect *arg2 = (wxRect *) 0 ;
23286 void *argp1 = 0 ;
23287 int res1 = 0 ;
23288 void *argp2 = 0 ;
23289 int res2 = 0 ;
23290 PyObject *swig_obj[2] ;
23291
23292 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23294 if (!SWIG_IsOK(res1)) {
23295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23296 }
23297 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23299 if (!SWIG_IsOK(res2)) {
23300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23301 }
23302 arg2 = reinterpret_cast< wxRect * >(argp2);
23303 if (arg1) (arg1)->m_rect = *arg2;
23304
23305 resultobj = SWIG_Py_Void();
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23313 PyObject *resultobj = 0;
23314 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23315 wxRect *result = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 PyObject *swig_obj[1] ;
23319
23320 if (!args) SWIG_fail;
23321 swig_obj[0] = args;
23322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23323 if (!SWIG_IsOK(res1)) {
23324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23325 }
23326 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23327 result = (wxRect *)& ((arg1)->m_rect);
23328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *obj;
23337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23338 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23339 return SWIG_Py_Void();
23340 }
23341
23342 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 return SWIG_Python_InitShadowInstance(args);
23344 }
23345
23346 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj = 0;
23348 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23349 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23350 int arg2 = (int) 0 ;
23351 wxMoveEvent *result = 0 ;
23352 wxPoint temp1 ;
23353 int val2 ;
23354 int ecode2 = 0 ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char * kwnames[] = {
23358 (char *) "pos",(char *) "winid", NULL
23359 };
23360
23361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23362 if (obj0) {
23363 {
23364 arg1 = &temp1;
23365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23366 }
23367 }
23368 if (obj1) {
23369 ecode2 = SWIG_AsVal_int(obj1, &val2);
23370 if (!SWIG_IsOK(ecode2)) {
23371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23372 }
23373 arg2 = static_cast< int >(val2);
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23391 wxPoint result;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 PyObject *swig_obj[1] ;
23395
23396 if (!args) SWIG_fail;
23397 swig_obj[0] = args;
23398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23401 }
23402 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = ((wxMoveEvent const *)arg1)->GetPosition();
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 PyObject *resultobj = 0;
23418 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23419 wxRect result;
23420 void *argp1 = 0 ;
23421 int res1 = 0 ;
23422 PyObject *swig_obj[1] ;
23423
23424 if (!args) SWIG_fail;
23425 swig_obj[0] = args;
23426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23427 if (!SWIG_IsOK(res1)) {
23428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23429 }
23430 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = ((wxMoveEvent const *)arg1)->GetRect();
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj = 0;
23446 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23447 wxRect *arg2 = 0 ;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 wxRect temp2 ;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 char * kwnames[] = {
23454 (char *) "self",(char *) "rect", NULL
23455 };
23456
23457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23459 if (!SWIG_IsOK(res1)) {
23460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23461 }
23462 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23463 {
23464 arg2 = &temp2;
23465 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 (arg1)->SetRect((wxRect const &)*arg2);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_Py_Void();
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23483 wxPoint *arg2 = 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 wxPoint temp2 ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "self",(char *) "pos", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23495 if (!SWIG_IsOK(res1)) {
23496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23497 }
23498 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23499 {
23500 arg2 = &temp2;
23501 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 (arg1)->SetPosition((wxPoint const &)*arg2);
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 resultobj = SWIG_Py_Void();
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *obj;
23518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23519 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23520 return SWIG_Py_Void();
23521 }
23522
23523 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 return SWIG_Python_InitShadowInstance(args);
23525 }
23526
23527 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 int arg1 = (int) 0 ;
23530 wxPaintEvent *result = 0 ;
23531 int val1 ;
23532 int ecode1 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 char * kwnames[] = {
23535 (char *) "Id", NULL
23536 };
23537
23538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23539 if (obj0) {
23540 ecode1 = SWIG_AsVal_int(obj0, &val1);
23541 if (!SWIG_IsOK(ecode1)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23543 }
23544 arg1 = static_cast< int >(val1);
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23560 PyObject *obj;
23561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23563 return SWIG_Py_Void();
23564 }
23565
23566 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23567 return SWIG_Python_InitShadowInstance(args);
23568 }
23569
23570 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj = 0;
23572 int arg1 = (int) 0 ;
23573 wxNcPaintEvent *result = 0 ;
23574 int val1 ;
23575 int ecode1 = 0 ;
23576 PyObject * obj0 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "winid", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23582 if (obj0) {
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23586 }
23587 arg1 = static_cast< int >(val1);
23588 }
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 PyObject *obj;
23604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23605 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23606 return SWIG_Py_Void();
23607 }
23608
23609 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 return SWIG_Python_InitShadowInstance(args);
23611 }
23612
23613 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj = 0;
23615 int arg1 = (int) 0 ;
23616 wxDC *arg2 = (wxDC *) NULL ;
23617 wxEraseEvent *result = 0 ;
23618 int val1 ;
23619 int ecode1 = 0 ;
23620 void *argp2 = 0 ;
23621 int res2 = 0 ;
23622 PyObject * obj0 = 0 ;
23623 PyObject * obj1 = 0 ;
23624 char * kwnames[] = {
23625 (char *) "Id",(char *) "dc", NULL
23626 };
23627
23628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23629 if (obj0) {
23630 ecode1 = SWIG_AsVal_int(obj0, &val1);
23631 if (!SWIG_IsOK(ecode1)) {
23632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23633 }
23634 arg1 = static_cast< int >(val1);
23635 }
23636 if (obj1) {
23637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23638 if (!SWIG_IsOK(res2)) {
23639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23640 }
23641 arg2 = reinterpret_cast< wxDC * >(argp2);
23642 }
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23646 wxPyEndAllowThreads(__tstate);
23647 if (PyErr_Occurred()) SWIG_fail;
23648 }
23649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23650 return resultobj;
23651 fail:
23652 return NULL;
23653 }
23654
23655
23656 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23657 PyObject *resultobj = 0;
23658 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23659 wxDC *result = 0 ;
23660 void *argp1 = 0 ;
23661 int res1 = 0 ;
23662 PyObject *swig_obj[1] ;
23663
23664 if (!args) SWIG_fail;
23665 swig_obj[0] = args;
23666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23667 if (!SWIG_IsOK(res1)) {
23668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23669 }
23670 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = wxPyMake_wxObject(result, (bool)0);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *obj;
23688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23689 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23690 return SWIG_Py_Void();
23691 }
23692
23693 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694 return SWIG_Python_InitShadowInstance(args);
23695 }
23696
23697 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj = 0;
23699 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23700 int arg2 = (int) 0 ;
23701 wxFocusEvent *result = 0 ;
23702 int val1 ;
23703 int ecode1 = 0 ;
23704 int val2 ;
23705 int ecode2 = 0 ;
23706 PyObject * obj0 = 0 ;
23707 PyObject * obj1 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "type",(char *) "winid", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23713 if (obj0) {
23714 ecode1 = SWIG_AsVal_int(obj0, &val1);
23715 if (!SWIG_IsOK(ecode1)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23717 }
23718 arg1 = static_cast< wxEventType >(val1);
23719 }
23720 if (obj1) {
23721 ecode2 = SWIG_AsVal_int(obj1, &val2);
23722 if (!SWIG_IsOK(ecode2)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23724 }
23725 arg2 = static_cast< int >(val2);
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 PyObject *resultobj = 0;
23742 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23743 wxWindow *result = 0 ;
23744 void *argp1 = 0 ;
23745 int res1 = 0 ;
23746 PyObject *swig_obj[1] ;
23747
23748 if (!args) SWIG_fail;
23749 swig_obj[0] = args;
23750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23753 }
23754 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 {
23762 resultobj = wxPyMake_wxObject(result, (bool)0);
23763 }
23764 return resultobj;
23765 fail:
23766 return NULL;
23767 }
23768
23769
23770 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23773 wxWindow *arg2 = (wxWindow *) 0 ;
23774 void *argp1 = 0 ;
23775 int res1 = 0 ;
23776 void *argp2 = 0 ;
23777 int res2 = 0 ;
23778 PyObject * obj0 = 0 ;
23779 PyObject * obj1 = 0 ;
23780 char * kwnames[] = {
23781 (char *) "self",(char *) "win", NULL
23782 };
23783
23784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23786 if (!SWIG_IsOK(res1)) {
23787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23788 }
23789 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23791 if (!SWIG_IsOK(res2)) {
23792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23793 }
23794 arg2 = reinterpret_cast< wxWindow * >(argp2);
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 (arg1)->SetWindow(arg2);
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_Py_Void();
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxWindow *arg1 = (wxWindow *) NULL ;
23822 wxChildFocusEvent *result = 0 ;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "win", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23831 if (obj0) {
23832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23833 if (!SWIG_IsOK(res1)) {
23834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23835 }
23836 arg1 = reinterpret_cast< wxWindow * >(argp1);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *resultobj = 0;
23853 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23854 wxWindow *result = 0 ;
23855 void *argp1 = 0 ;
23856 int res1 = 0 ;
23857 PyObject *swig_obj[1] ;
23858
23859 if (!args) SWIG_fail;
23860 swig_obj[0] = args;
23861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23862 if (!SWIG_IsOK(res1)) {
23863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23864 }
23865 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 resultobj = wxPyMake_wxObject(result, (bool)0);
23874 }
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23882 PyObject *obj;
23883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23884 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23885 return SWIG_Py_Void();
23886 }
23887
23888 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 return SWIG_Python_InitShadowInstance(args);
23890 }
23891
23892 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23895 bool arg2 = (bool) true ;
23896 int arg3 = (int) 0 ;
23897 wxActivateEvent *result = 0 ;
23898 int val1 ;
23899 int ecode1 = 0 ;
23900 bool val2 ;
23901 int ecode2 = 0 ;
23902 int val3 ;
23903 int ecode3 = 0 ;
23904 PyObject * obj0 = 0 ;
23905 PyObject * obj1 = 0 ;
23906 PyObject * obj2 = 0 ;
23907 char * kwnames[] = {
23908 (char *) "type",(char *) "active",(char *) "Id", NULL
23909 };
23910
23911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23912 if (obj0) {
23913 ecode1 = SWIG_AsVal_int(obj0, &val1);
23914 if (!SWIG_IsOK(ecode1)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23916 }
23917 arg1 = static_cast< wxEventType >(val1);
23918 }
23919 if (obj1) {
23920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23921 if (!SWIG_IsOK(ecode2)) {
23922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23923 }
23924 arg2 = static_cast< bool >(val2);
23925 }
23926 if (obj2) {
23927 ecode3 = SWIG_AsVal_int(obj2, &val3);
23928 if (!SWIG_IsOK(ecode3)) {
23929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23930 }
23931 arg3 = static_cast< int >(val3);
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23947 PyObject *resultobj = 0;
23948 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23949 bool result;
23950 void *argp1 = 0 ;
23951 int res1 = 0 ;
23952 PyObject *swig_obj[1] ;
23953
23954 if (!args) SWIG_fail;
23955 swig_obj[0] = args;
23956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23959 }
23960 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 {
23968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *obj;
23978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23979 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23980 return SWIG_Py_Void();
23981 }
23982
23983 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 return SWIG_Python_InitShadowInstance(args);
23985 }
23986
23987 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23988 PyObject *resultobj = 0;
23989 int arg1 = (int) 0 ;
23990 wxInitDialogEvent *result = 0 ;
23991 int val1 ;
23992 int ecode1 = 0 ;
23993 PyObject * obj0 = 0 ;
23994 char * kwnames[] = {
23995 (char *) "Id", NULL
23996 };
23997
23998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23999 if (obj0) {
24000 ecode1 = SWIG_AsVal_int(obj0, &val1);
24001 if (!SWIG_IsOK(ecode1)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24003 }
24004 arg1 = static_cast< int >(val1);
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *obj;
24021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24022 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24023 return SWIG_Py_Void();
24024 }
24025
24026 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 return SWIG_Python_InitShadowInstance(args);
24028 }
24029
24030 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj = 0;
24032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24033 int arg2 = (int) 0 ;
24034 wxMenu *arg3 = (wxMenu *) NULL ;
24035 wxMenuEvent *result = 0 ;
24036 int val1 ;
24037 int ecode1 = 0 ;
24038 int val2 ;
24039 int ecode2 = 0 ;
24040 void *argp3 = 0 ;
24041 int res3 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 PyObject * obj2 = 0 ;
24045 char * kwnames[] = {
24046 (char *) "type",(char *) "winid",(char *) "menu", NULL
24047 };
24048
24049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24050 if (obj0) {
24051 ecode1 = SWIG_AsVal_int(obj0, &val1);
24052 if (!SWIG_IsOK(ecode1)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24054 }
24055 arg1 = static_cast< wxEventType >(val1);
24056 }
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24061 }
24062 arg2 = static_cast< int >(val2);
24063 }
24064 if (obj2) {
24065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24066 if (!SWIG_IsOK(res3)) {
24067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24068 }
24069 arg3 = reinterpret_cast< wxMenu * >(argp3);
24070 }
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24085 PyObject *resultobj = 0;
24086 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24087 int result;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24097 }
24098 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_From_int(static_cast< int >(result));
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24113 PyObject *resultobj = 0;
24114 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24115 bool result;
24116 void *argp1 = 0 ;
24117 int res1 = 0 ;
24118 PyObject *swig_obj[1] ;
24119
24120 if (!args) SWIG_fail;
24121 swig_obj[0] = args;
24122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24123 if (!SWIG_IsOK(res1)) {
24124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24125 }
24126 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24145 wxMenu *result = 0 ;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = wxPyMake_wxObject(result, (bool)0);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24186 int arg2 = (int) 0 ;
24187 wxCloseEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 int val2 ;
24191 int ecode2 = 0 ;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "type",(char *) "winid", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24199 if (obj0) {
24200 ecode1 = SWIG_AsVal_int(obj0, &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24203 }
24204 arg1 = static_cast< wxEventType >(val1);
24205 }
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_int(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24210 }
24211 arg2 = static_cast< int >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24229 bool arg2 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 bool val2 ;
24233 int ecode2 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "logOff", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24249 }
24250 arg2 = static_cast< bool >(val2);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetLoggingOff(arg2);
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_Py_Void();
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24267 bool result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj = 0;
24296 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24297 bool arg2 = (bool) true ;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 bool val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "self",(char *) "veto", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24314 if (obj1) {
24315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24316 if (!SWIG_IsOK(ecode2)) {
24317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24318 }
24319 arg2 = static_cast< bool >(val2);
24320 }
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 (arg1)->Veto(arg2);
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 resultobj = SWIG_Py_Void();
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 PyObject *resultobj = 0;
24336 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24337 bool result;
24338 void *argp1 = 0 ;
24339 int res1 = 0 ;
24340 PyObject *swig_obj[1] ;
24341
24342 if (!args) SWIG_fail;
24343 swig_obj[0] = args;
24344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24345 if (!SWIG_IsOK(res1)) {
24346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24347 }
24348 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24349 {
24350 PyThreadState* __tstate = wxPyBeginAllowThreads();
24351 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 {
24356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24357 }
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj = 0;
24366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24367 bool arg2 ;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 bool val2 ;
24371 int ecode2 = 0 ;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 char * kwnames[] = {
24375 (char *) "self",(char *) "canVeto", NULL
24376 };
24377
24378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24380 if (!SWIG_IsOK(res1)) {
24381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24382 }
24383 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24385 if (!SWIG_IsOK(ecode2)) {
24386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24387 }
24388 arg2 = static_cast< bool >(val2);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 (arg1)->SetCanVeto(arg2);
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_Py_Void();
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 PyObject *resultobj = 0;
24404 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24405 bool result;
24406 void *argp1 = 0 ;
24407 int res1 = 0 ;
24408 PyObject *swig_obj[1] ;
24409
24410 if (!args) SWIG_fail;
24411 swig_obj[0] = args;
24412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24415 }
24416 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24417 {
24418 PyThreadState* __tstate = wxPyBeginAllowThreads();
24419 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 {
24424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24425 }
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *obj;
24434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24435 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24436 return SWIG_Py_Void();
24437 }
24438
24439 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24440 return SWIG_Python_InitShadowInstance(args);
24441 }
24442
24443 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj = 0;
24445 int arg1 = (int) 0 ;
24446 bool arg2 = (bool) false ;
24447 wxShowEvent *result = 0 ;
24448 int val1 ;
24449 int ecode1 = 0 ;
24450 bool val2 ;
24451 int ecode2 = 0 ;
24452 PyObject * obj0 = 0 ;
24453 PyObject * obj1 = 0 ;
24454 char * kwnames[] = {
24455 (char *) "winid",(char *) "show", NULL
24456 };
24457
24458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24459 if (obj0) {
24460 ecode1 = SWIG_AsVal_int(obj0, &val1);
24461 if (!SWIG_IsOK(ecode1)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24463 }
24464 arg1 = static_cast< int >(val1);
24465 }
24466 if (obj1) {
24467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24468 if (!SWIG_IsOK(ecode2)) {
24469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24470 }
24471 arg2 = static_cast< bool >(val2);
24472 }
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj = 0;
24488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24489 bool arg2 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 bool val2 ;
24493 int ecode2 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 char * kwnames[] = {
24497 (char *) "self",(char *) "show", NULL
24498 };
24499
24500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24504 }
24505 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24509 }
24510 arg2 = static_cast< bool >(val2);
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 (arg1)->SetShow(arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_Py_Void();
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24527 bool result;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *obj;
24556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24557 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24558 return SWIG_Py_Void();
24559 }
24560
24561 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 return SWIG_Python_InitShadowInstance(args);
24563 }
24564
24565 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = 0;
24567 int arg1 = (int) 0 ;
24568 bool arg2 = (bool) true ;
24569 wxIconizeEvent *result = 0 ;
24570 int val1 ;
24571 int ecode1 = 0 ;
24572 bool val2 ;
24573 int ecode2 = 0 ;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char * kwnames[] = {
24577 (char *) "id",(char *) "iconized", NULL
24578 };
24579
24580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24581 if (obj0) {
24582 ecode1 = SWIG_AsVal_int(obj0, &val1);
24583 if (!SWIG_IsOK(ecode1)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24585 }
24586 arg1 = static_cast< int >(val1);
24587 }
24588 if (obj1) {
24589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24592 }
24593 arg2 = static_cast< bool >(val2);
24594 }
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24609 PyObject *resultobj = 0;
24610 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24611 bool result;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 PyObject *swig_obj[1] ;
24615
24616 if (!args) SWIG_fail;
24617 swig_obj[0] = args;
24618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24621 }
24622 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 result = (bool)(arg1)->Iconized();
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24639 PyObject *obj;
24640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24641 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24642 return SWIG_Py_Void();
24643 }
24644
24645 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 return SWIG_Python_InitShadowInstance(args);
24647 }
24648
24649 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj = 0;
24651 int arg1 = (int) 0 ;
24652 wxMaximizeEvent *result = 0 ;
24653 int val1 ;
24654 int ecode1 = 0 ;
24655 PyObject * obj0 = 0 ;
24656 char * kwnames[] = {
24657 (char *) "id", NULL
24658 };
24659
24660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24661 if (obj0) {
24662 ecode1 = SWIG_AsVal_int(obj0, &val1);
24663 if (!SWIG_IsOK(ecode1)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24665 }
24666 arg1 = static_cast< int >(val1);
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *obj;
24683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24684 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24685 return SWIG_Py_Void();
24686 }
24687
24688 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24689 return SWIG_Python_InitShadowInstance(args);
24690 }
24691
24692 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24695 wxPoint result;
24696 void *argp1 = 0 ;
24697 int res1 = 0 ;
24698 PyObject *swig_obj[1] ;
24699
24700 if (!args) SWIG_fail;
24701 swig_obj[0] = args;
24702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24705 }
24706 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (arg1)->GetPosition();
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721 PyObject *resultobj = 0;
24722 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24723 int result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 PyObject *swig_obj[1] ;
24727
24728 if (!args) SWIG_fail;
24729 swig_obj[0] = args;
24730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24733 }
24734 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (int)(arg1)->GetNumberOfFiles();
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_From_int(static_cast< int >(result));
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24751 PyObject *result = 0 ;
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_wxDropFilesEvent, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24761 }
24762 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 resultobj = result;
24770 return resultobj;
24771 fail:
24772 return NULL;
24773 }
24774
24775
24776 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24777 PyObject *obj;
24778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24779 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24780 return SWIG_Py_Void();
24781 }
24782
24783 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj = 0;
24785 int arg1 = (int) 0 ;
24786 wxUpdateUIEvent *result = 0 ;
24787 int val1 ;
24788 int ecode1 = 0 ;
24789 PyObject * obj0 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "commandId", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24795 if (obj0) {
24796 ecode1 = SWIG_AsVal_int(obj0, &val1);
24797 if (!SWIG_IsOK(ecode1)) {
24798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24799 }
24800 arg1 = static_cast< int >(val1);
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24805 wxPyEndAllowThreads(__tstate);
24806 if (PyErr_Occurred()) SWIG_fail;
24807 }
24808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24816 PyObject *resultobj = 0;
24817 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24818 bool result;
24819 void *argp1 = 0 ;
24820 int res1 = 0 ;
24821 PyObject *swig_obj[1] ;
24822
24823 if (!args) SWIG_fail;
24824 swig_obj[0] = args;
24825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24826 if (!SWIG_IsOK(res1)) {
24827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24828 }
24829 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24830 {
24831 PyThreadState* __tstate = wxPyBeginAllowThreads();
24832 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24848 bool result;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 PyObject *swig_obj[1] ;
24852
24853 if (!args) SWIG_fail;
24854 swig_obj[0] = args;
24855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24858 }
24859 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 {
24867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24868 }
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24876 PyObject *resultobj = 0;
24877 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24878 bool result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 PyObject *swig_obj[1] ;
24882
24883 if (!args) SWIG_fail;
24884 swig_obj[0] = args;
24885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24886 if (!SWIG_IsOK(res1)) {
24887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24888 }
24889 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24898 }
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24906 PyObject *resultobj = 0;
24907 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24908 wxString result;
24909 void *argp1 = 0 ;
24910 int res1 = 0 ;
24911 PyObject *swig_obj[1] ;
24912
24913 if (!args) SWIG_fail;
24914 swig_obj[0] = args;
24915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24916 if (!SWIG_IsOK(res1)) {
24917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24918 }
24919 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 #if wxUSE_UNICODE
24928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24929 #else
24930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24931 #endif
24932 }
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24940 PyObject *resultobj = 0;
24941 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24942 bool result;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 PyObject *swig_obj[1] ;
24946
24947 if (!args) SWIG_fail;
24948 swig_obj[0] = args;
24949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24950 if (!SWIG_IsOK(res1)) {
24951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24952 }
24953 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 PyObject *resultobj = 0;
24971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24972 bool result;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 PyObject *swig_obj[1] ;
24976
24977 if (!args) SWIG_fail;
24978 swig_obj[0] = args;
24979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24980 if (!SWIG_IsOK(res1)) {
24981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24982 }
24983 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25000 PyObject *resultobj = 0;
25001 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25002 bool result;
25003 void *argp1 = 0 ;
25004 int res1 = 0 ;
25005 PyObject *swig_obj[1] ;
25006
25007 if (!args) SWIG_fail;
25008 swig_obj[0] = args;
25009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25012 }
25013 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25030 PyObject *resultobj = 0;
25031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25032 bool result;
25033 void *argp1 = 0 ;
25034 int res1 = 0 ;
25035 PyObject *swig_obj[1] ;
25036
25037 if (!args) SWIG_fail;
25038 swig_obj[0] = args;
25039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25042 }
25043 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25052 }
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj = 0;
25061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25062 bool arg2 ;
25063 void *argp1 = 0 ;
25064 int res1 = 0 ;
25065 bool val2 ;
25066 int ecode2 = 0 ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "check", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25077 }
25078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25082 }
25083 arg2 = static_cast< bool >(val2);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 (arg1)->Check(arg2);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25100 bool arg2 ;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 bool val2 ;
25104 int ecode2 = 0 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char * kwnames[] = {
25108 (char *) "self",(char *) "enable", NULL
25109 };
25110
25111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25118 if (!SWIG_IsOK(ecode2)) {
25119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25120 }
25121 arg2 = static_cast< bool >(val2);
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 (arg1)->Enable(arg2);
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 resultobj = SWIG_Py_Void();
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj = 0;
25137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25138 bool arg2 ;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 bool val2 ;
25142 int ecode2 = 0 ;
25143 PyObject * obj0 = 0 ;
25144 PyObject * obj1 = 0 ;
25145 char * kwnames[] = {
25146 (char *) "self",(char *) "show", NULL
25147 };
25148
25149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25153 }
25154 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25156 if (!SWIG_IsOK(ecode2)) {
25157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25158 }
25159 arg2 = static_cast< bool >(val2);
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 (arg1)->Show(arg2);
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 resultobj = SWIG_Py_Void();
25167 return resultobj;
25168 fail:
25169 return NULL;
25170 }
25171
25172
25173 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25174 PyObject *resultobj = 0;
25175 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25176 wxString *arg2 = 0 ;
25177 void *argp1 = 0 ;
25178 int res1 = 0 ;
25179 bool temp2 = false ;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 char * kwnames[] = {
25183 (char *) "self",(char *) "text", NULL
25184 };
25185
25186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25190 }
25191 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25192 {
25193 arg2 = wxString_in_helper(obj1);
25194 if (arg2 == NULL) SWIG_fail;
25195 temp2 = true;
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 (arg1)->SetText((wxString const &)*arg2);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_Py_Void();
25204 {
25205 if (temp2)
25206 delete arg2;
25207 }
25208 return resultobj;
25209 fail:
25210 {
25211 if (temp2)
25212 delete arg2;
25213 }
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 long arg1 ;
25221 long val1 ;
25222 int ecode1 = 0 ;
25223 PyObject * obj0 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "updateInterval", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25229 ecode1 = SWIG_AsVal_long(obj0, &val1);
25230 if (!SWIG_IsOK(ecode1)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25232 }
25233 arg1 = static_cast< long >(val1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxUpdateUIEvent::SetUpdateInterval(arg1);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 long result;
25250
25251 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_From_long(static_cast< long >(result));
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj = 0;
25267 wxWindow *arg1 = (wxWindow *) 0 ;
25268 bool result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 char * kwnames[] = {
25273 (char *) "win", NULL
25274 };
25275
25276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25278 if (!SWIG_IsOK(res1)) {
25279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25280 }
25281 arg1 = reinterpret_cast< wxWindow * >(argp1);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 {
25289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25290 }
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25298 PyObject *resultobj = 0;
25299
25300 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 wxUpdateUIEvent::ResetUpdateTime();
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 resultobj = SWIG_Py_Void();
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = 0;
25316 wxUpdateUIMode arg1 ;
25317 int val1 ;
25318 int ecode1 = 0 ;
25319 PyObject * obj0 = 0 ;
25320 char * kwnames[] = {
25321 (char *) "mode", NULL
25322 };
25323
25324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25325 ecode1 = SWIG_AsVal_int(obj0, &val1);
25326 if (!SWIG_IsOK(ecode1)) {
25327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25328 }
25329 arg1 = static_cast< wxUpdateUIMode >(val1);
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 wxUpdateUIEvent::SetMode(arg1);
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_Py_Void();
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25344 PyObject *resultobj = 0;
25345 wxUpdateUIMode result;
25346
25347 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 resultobj = SWIG_From_int(static_cast< int >(result));
25355 return resultobj;
25356 fail:
25357 return NULL;
25358 }
25359
25360
25361 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 PyObject *obj;
25363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25364 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25365 return SWIG_Py_Void();
25366 }
25367
25368 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25369 return SWIG_Python_InitShadowInstance(args);
25370 }
25371
25372 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25373 PyObject *resultobj = 0;
25374 wxSysColourChangedEvent *result = 0 ;
25375
25376 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25391 PyObject *obj;
25392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25393 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25394 return SWIG_Py_Void();
25395 }
25396
25397 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25398 return SWIG_Python_InitShadowInstance(args);
25399 }
25400
25401 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj = 0;
25403 int arg1 = (int) 0 ;
25404 wxWindow *arg2 = (wxWindow *) NULL ;
25405 wxMouseCaptureChangedEvent *result = 0 ;
25406 int val1 ;
25407 int ecode1 = 0 ;
25408 void *argp2 = 0 ;
25409 int res2 = 0 ;
25410 PyObject * obj0 = 0 ;
25411 PyObject * obj1 = 0 ;
25412 char * kwnames[] = {
25413 (char *) "winid",(char *) "gainedCapture", NULL
25414 };
25415
25416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25417 if (obj0) {
25418 ecode1 = SWIG_AsVal_int(obj0, &val1);
25419 if (!SWIG_IsOK(ecode1)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25421 }
25422 arg1 = static_cast< int >(val1);
25423 }
25424 if (obj1) {
25425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25426 if (!SWIG_IsOK(res2)) {
25427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25428 }
25429 arg2 = reinterpret_cast< wxWindow * >(argp2);
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25447 wxWindow *result = 0 ;
25448 void *argp1 = 0 ;
25449 int res1 = 0 ;
25450 PyObject *swig_obj[1] ;
25451
25452 if (!args) SWIG_fail;
25453 swig_obj[0] = args;
25454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25457 }
25458 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 {
25466 resultobj = wxPyMake_wxObject(result, (bool)0);
25467 }
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475 PyObject *obj;
25476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25477 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25478 return SWIG_Py_Void();
25479 }
25480
25481 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25482 return SWIG_Python_InitShadowInstance(args);
25483 }
25484
25485 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25486 PyObject *resultobj = 0;
25487 wxDisplayChangedEvent *result = 0 ;
25488
25489 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25493 wxPyEndAllowThreads(__tstate);
25494 if (PyErr_Occurred()) SWIG_fail;
25495 }
25496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *obj;
25505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25506 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25507 return SWIG_Py_Void();
25508 }
25509
25510 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 return SWIG_Python_InitShadowInstance(args);
25512 }
25513
25514 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj = 0;
25516 int arg1 = (int) 0 ;
25517 wxPaletteChangedEvent *result = 0 ;
25518 int val1 ;
25519 int ecode1 = 0 ;
25520 PyObject * obj0 = 0 ;
25521 char * kwnames[] = {
25522 (char *) "id", NULL
25523 };
25524
25525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25526 if (obj0) {
25527 ecode1 = SWIG_AsVal_int(obj0, &val1);
25528 if (!SWIG_IsOK(ecode1)) {
25529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25530 }
25531 arg1 = static_cast< int >(val1);
25532 }
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj = 0;
25548 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25549 wxWindow *arg2 = (wxWindow *) 0 ;
25550 void *argp1 = 0 ;
25551 int res1 = 0 ;
25552 void *argp2 = 0 ;
25553 int res2 = 0 ;
25554 PyObject * obj0 = 0 ;
25555 PyObject * obj1 = 0 ;
25556 char * kwnames[] = {
25557 (char *) "self",(char *) "win", NULL
25558 };
25559
25560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25562 if (!SWIG_IsOK(res1)) {
25563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25564 }
25565 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25567 if (!SWIG_IsOK(res2)) {
25568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25569 }
25570 arg2 = reinterpret_cast< wxWindow * >(argp2);
25571 {
25572 PyThreadState* __tstate = wxPyBeginAllowThreads();
25573 (arg1)->SetChangedWindow(arg2);
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_Py_Void();
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25585 PyObject *resultobj = 0;
25586 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 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_wxPaletteChangedEvent, 0 | 0 );
25595 if (!SWIG_IsOK(res1)) {
25596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25597 }
25598 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 result = (wxWindow *)(arg1)->GetChangedWindow();
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 *PaletteChangedEvent_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_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25618 return SWIG_Py_Void();
25619 }
25620
25621 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25622 return SWIG_Python_InitShadowInstance(args);
25623 }
25624
25625 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25626 PyObject *resultobj = 0;
25627 int arg1 = (int) 0 ;
25628 wxQueryNewPaletteEvent *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_QueryNewPaletteEvent",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_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25641 }
25642 arg1 = static_cast< int >(val1);
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25658 PyObject *resultobj = 0;
25659 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25660 bool arg2 ;
25661 void *argp1 = 0 ;
25662 int res1 = 0 ;
25663 bool val2 ;
25664 int ecode2 = 0 ;
25665 PyObject * obj0 = 0 ;
25666 PyObject * obj1 = 0 ;
25667 char * kwnames[] = {
25668 (char *) "self",(char *) "realized", NULL
25669 };
25670
25671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25673 if (!SWIG_IsOK(res1)) {
25674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25675 }
25676 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25677 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25678 if (!SWIG_IsOK(ecode2)) {
25679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25680 }
25681 arg2 = static_cast< bool >(val2);
25682 {
25683 PyThreadState* __tstate = wxPyBeginAllowThreads();
25684 (arg1)->SetPaletteRealized(arg2);
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 resultobj = SWIG_Py_Void();
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25696 PyObject *resultobj = 0;
25697 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25698 bool result;
25699 void *argp1 = 0 ;
25700 int res1 = 0 ;
25701 PyObject *swig_obj[1] ;
25702
25703 if (!args) SWIG_fail;
25704 swig_obj[0] = args;
25705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25706 if (!SWIG_IsOK(res1)) {
25707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25708 }
25709 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 {
25717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25718 }
25719 return resultobj;
25720 fail:
25721 return NULL;
25722 }
25723
25724
25725 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 PyObject *obj;
25727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25728 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25729 return SWIG_Py_Void();
25730 }
25731
25732 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25733 return SWIG_Python_InitShadowInstance(args);
25734 }
25735
25736 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737 PyObject *resultobj = 0;
25738 wxNavigationKeyEvent *result = 0 ;
25739
25740 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25744 wxPyEndAllowThreads(__tstate);
25745 if (PyErr_Occurred()) SWIG_fail;
25746 }
25747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25748 return resultobj;
25749 fail:
25750 return NULL;
25751 }
25752
25753
25754 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25755 PyObject *resultobj = 0;
25756 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25757 bool result;
25758 void *argp1 = 0 ;
25759 int res1 = 0 ;
25760 PyObject *swig_obj[1] ;
25761
25762 if (!args) SWIG_fail;
25763 swig_obj[0] = args;
25764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25765 if (!SWIG_IsOK(res1)) {
25766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25767 }
25768 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25769 {
25770 PyThreadState* __tstate = wxPyBeginAllowThreads();
25771 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 {
25776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25777 }
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25785 PyObject *resultobj = 0;
25786 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25787 bool arg2 ;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 bool val2 ;
25791 int ecode2 = 0 ;
25792 PyObject * obj0 = 0 ;
25793 PyObject * obj1 = 0 ;
25794 char * kwnames[] = {
25795 (char *) "self",(char *) "forward", NULL
25796 };
25797
25798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25800 if (!SWIG_IsOK(res1)) {
25801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25802 }
25803 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25805 if (!SWIG_IsOK(ecode2)) {
25806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25807 }
25808 arg2 = static_cast< bool >(val2);
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 (arg1)->SetDirection(arg2);
25812 wxPyEndAllowThreads(__tstate);
25813 if (PyErr_Occurred()) SWIG_fail;
25814 }
25815 resultobj = SWIG_Py_Void();
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25823 PyObject *resultobj = 0;
25824 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25825 bool result;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 PyObject *swig_obj[1] ;
25829
25830 if (!args) SWIG_fail;
25831 swig_obj[0] = args;
25832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25833 if (!SWIG_IsOK(res1)) {
25834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25835 }
25836 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25840 wxPyEndAllowThreads(__tstate);
25841 if (PyErr_Occurred()) SWIG_fail;
25842 }
25843 {
25844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25845 }
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj = 0;
25854 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25855 bool arg2 ;
25856 void *argp1 = 0 ;
25857 int res1 = 0 ;
25858 bool val2 ;
25859 int ecode2 = 0 ;
25860 PyObject * obj0 = 0 ;
25861 PyObject * obj1 = 0 ;
25862 char * kwnames[] = {
25863 (char *) "self",(char *) "ischange", NULL
25864 };
25865
25866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25868 if (!SWIG_IsOK(res1)) {
25869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25870 }
25871 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25873 if (!SWIG_IsOK(ecode2)) {
25874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25875 }
25876 arg2 = static_cast< bool >(val2);
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 (arg1)->SetWindowChange(arg2);
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 resultobj = SWIG_Py_Void();
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 PyObject *resultobj = 0;
25892 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25893 bool result;
25894 void *argp1 = 0 ;
25895 int res1 = 0 ;
25896 PyObject *swig_obj[1] ;
25897
25898 if (!args) SWIG_fail;
25899 swig_obj[0] = args;
25900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25901 if (!SWIG_IsOK(res1)) {
25902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25903 }
25904 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 {
25912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25913 }
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj = 0;
25922 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25923 bool arg2 ;
25924 void *argp1 = 0 ;
25925 int res1 = 0 ;
25926 bool val2 ;
25927 int ecode2 = 0 ;
25928 PyObject * obj0 = 0 ;
25929 PyObject * obj1 = 0 ;
25930 char * kwnames[] = {
25931 (char *) "self",(char *) "bIs", NULL
25932 };
25933
25934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25936 if (!SWIG_IsOK(res1)) {
25937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25938 }
25939 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25940 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25941 if (!SWIG_IsOK(ecode2)) {
25942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25943 }
25944 arg2 = static_cast< bool >(val2);
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 (arg1)->SetFromTab(arg2);
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_Py_Void();
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = 0;
25960 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25961 long arg2 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 long val2 ;
25965 int ecode2 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char * kwnames[] = {
25969 (char *) "self",(char *) "flags", NULL
25970 };
25971
25972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25976 }
25977 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25978 ecode2 = SWIG_AsVal_long(obj1, &val2);
25979 if (!SWIG_IsOK(ecode2)) {
25980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25981 }
25982 arg2 = static_cast< long >(val2);
25983 {
25984 PyThreadState* __tstate = wxPyBeginAllowThreads();
25985 (arg1)->SetFlags(arg2);
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 resultobj = SWIG_Py_Void();
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997 PyObject *resultobj = 0;
25998 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25999 wxWindow *result = 0 ;
26000 void *argp1 = 0 ;
26001 int res1 = 0 ;
26002 PyObject *swig_obj[1] ;
26003
26004 if (!args) SWIG_fail;
26005 swig_obj[0] = args;
26006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26007 if (!SWIG_IsOK(res1)) {
26008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26009 }
26010 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 {
26018 resultobj = wxPyMake_wxObject(result, (bool)0);
26019 }
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj = 0;
26028 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26029 wxWindow *arg2 = (wxWindow *) 0 ;
26030 void *argp1 = 0 ;
26031 int res1 = 0 ;
26032 void *argp2 = 0 ;
26033 int res2 = 0 ;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "self",(char *) "win", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26044 }
26045 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26047 if (!SWIG_IsOK(res2)) {
26048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26049 }
26050 arg2 = reinterpret_cast< wxWindow * >(argp2);
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 (arg1)->SetCurrentFocus(arg2);
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 resultobj = SWIG_Py_Void();
26058 return resultobj;
26059 fail:
26060 return NULL;
26061 }
26062
26063
26064 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26065 PyObject *obj;
26066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26067 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26068 return SWIG_Py_Void();
26069 }
26070
26071 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26072 return SWIG_Python_InitShadowInstance(args);
26073 }
26074
26075 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26076 PyObject *resultobj = 0;
26077 wxWindow *arg1 = (wxWindow *) NULL ;
26078 wxWindowCreateEvent *result = 0 ;
26079 void *argp1 = 0 ;
26080 int res1 = 0 ;
26081 PyObject * obj0 = 0 ;
26082 char * kwnames[] = {
26083 (char *) "win", NULL
26084 };
26085
26086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26087 if (obj0) {
26088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26089 if (!SWIG_IsOK(res1)) {
26090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26091 }
26092 arg1 = reinterpret_cast< wxWindow * >(argp1);
26093 }
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26110 wxWindow *result = 0 ;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 PyObject *swig_obj[1] ;
26114
26115 if (!args) SWIG_fail;
26116 swig_obj[0] = args;
26117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26120 }
26121 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 {
26129 resultobj = wxPyMake_wxObject(result, (bool)0);
26130 }
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26138 PyObject *obj;
26139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26140 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26141 return SWIG_Py_Void();
26142 }
26143
26144 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26145 return SWIG_Python_InitShadowInstance(args);
26146 }
26147
26148 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26149 PyObject *resultobj = 0;
26150 wxWindow *arg1 = (wxWindow *) NULL ;
26151 wxWindowDestroyEvent *result = 0 ;
26152 void *argp1 = 0 ;
26153 int res1 = 0 ;
26154 PyObject * obj0 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "win", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26160 if (obj0) {
26161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26164 }
26165 arg1 = reinterpret_cast< wxWindow * >(argp1);
26166 }
26167 {
26168 PyThreadState* __tstate = wxPyBeginAllowThreads();
26169 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26170 wxPyEndAllowThreads(__tstate);
26171 if (PyErr_Occurred()) SWIG_fail;
26172 }
26173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 PyObject *resultobj = 0;
26182 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26183 wxWindow *result = 0 ;
26184 void *argp1 = 0 ;
26185 int res1 = 0 ;
26186 PyObject *swig_obj[1] ;
26187
26188 if (!args) SWIG_fail;
26189 swig_obj[0] = args;
26190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26191 if (!SWIG_IsOK(res1)) {
26192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26193 }
26194 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 {
26202 resultobj = wxPyMake_wxObject(result, (bool)0);
26203 }
26204 return resultobj;
26205 fail:
26206 return NULL;
26207 }
26208
26209
26210 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26211 PyObject *obj;
26212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26213 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26214 return SWIG_Py_Void();
26215 }
26216
26217 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26218 return SWIG_Python_InitShadowInstance(args);
26219 }
26220
26221 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj = 0;
26223 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26224 int arg2 = (int) 0 ;
26225 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26226 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26227 wxContextMenuEvent *result = 0 ;
26228 int val1 ;
26229 int ecode1 = 0 ;
26230 int val2 ;
26231 int ecode2 = 0 ;
26232 wxPoint temp3 ;
26233 PyObject * obj0 = 0 ;
26234 PyObject * obj1 = 0 ;
26235 PyObject * obj2 = 0 ;
26236 char * kwnames[] = {
26237 (char *) "type",(char *) "winid",(char *) "pt", NULL
26238 };
26239
26240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26241 if (obj0) {
26242 ecode1 = SWIG_AsVal_int(obj0, &val1);
26243 if (!SWIG_IsOK(ecode1)) {
26244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26245 }
26246 arg1 = static_cast< wxEventType >(val1);
26247 }
26248 if (obj1) {
26249 ecode2 = SWIG_AsVal_int(obj1, &val2);
26250 if (!SWIG_IsOK(ecode2)) {
26251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26252 }
26253 arg2 = static_cast< int >(val2);
26254 }
26255 if (obj2) {
26256 {
26257 arg3 = &temp3;
26258 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26259 }
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26277 wxPoint *result = 0 ;
26278 void *argp1 = 0 ;
26279 int res1 = 0 ;
26280 PyObject *swig_obj[1] ;
26281
26282 if (!args) SWIG_fail;
26283 swig_obj[0] = args;
26284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26287 }
26288 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 {
26292 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26293 result = (wxPoint *) &_result_ref;
26294 }
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj = 0;
26307 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26308 wxPoint *arg2 = 0 ;
26309 void *argp1 = 0 ;
26310 int res1 = 0 ;
26311 wxPoint temp2 ;
26312 PyObject * obj0 = 0 ;
26313 PyObject * obj1 = 0 ;
26314 char * kwnames[] = {
26315 (char *) "self",(char *) "pos", NULL
26316 };
26317
26318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26320 if (!SWIG_IsOK(res1)) {
26321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26322 }
26323 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26324 {
26325 arg2 = &temp2;
26326 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26327 }
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 (arg1)->SetPosition((wxPoint const &)*arg2);
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26342 PyObject *obj;
26343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26344 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26345 return SWIG_Py_Void();
26346 }
26347
26348 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26349 return SWIG_Python_InitShadowInstance(args);
26350 }
26351
26352 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26353 PyObject *resultobj = 0;
26354 wxIdleEvent *result = 0 ;
26355
26356 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26357 {
26358 PyThreadState* __tstate = wxPyBeginAllowThreads();
26359 result = (wxIdleEvent *)new wxIdleEvent();
26360 wxPyEndAllowThreads(__tstate);
26361 if (PyErr_Occurred()) SWIG_fail;
26362 }
26363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26364 return resultobj;
26365 fail:
26366 return NULL;
26367 }
26368
26369
26370 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26371 PyObject *resultobj = 0;
26372 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26373 bool arg2 = (bool) true ;
26374 void *argp1 = 0 ;
26375 int res1 = 0 ;
26376 bool val2 ;
26377 int ecode2 = 0 ;
26378 PyObject * obj0 = 0 ;
26379 PyObject * obj1 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "self",(char *) "needMore", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26388 }
26389 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26390 if (obj1) {
26391 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26392 if (!SWIG_IsOK(ecode2)) {
26393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26394 }
26395 arg2 = static_cast< bool >(val2);
26396 }
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 (arg1)->RequestMore(arg2);
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 resultobj = SWIG_Py_Void();
26404 return resultobj;
26405 fail:
26406 return NULL;
26407 }
26408
26409
26410 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26411 PyObject *resultobj = 0;
26412 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26413 bool result;
26414 void *argp1 = 0 ;
26415 int res1 = 0 ;
26416 PyObject *swig_obj[1] ;
26417
26418 if (!args) SWIG_fail;
26419 swig_obj[0] = args;
26420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26421 if (!SWIG_IsOK(res1)) {
26422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26423 }
26424 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 {
26432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26433 }
26434 return resultobj;
26435 fail:
26436 return NULL;
26437 }
26438
26439
26440 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26441 PyObject *resultobj = 0;
26442 wxIdleMode arg1 ;
26443 int val1 ;
26444 int ecode1 = 0 ;
26445 PyObject * obj0 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "mode", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26451 ecode1 = SWIG_AsVal_int(obj0, &val1);
26452 if (!SWIG_IsOK(ecode1)) {
26453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26454 }
26455 arg1 = static_cast< wxIdleMode >(val1);
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 wxIdleEvent::SetMode(arg1);
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 resultobj = SWIG_Py_Void();
26463 return resultobj;
26464 fail:
26465 return NULL;
26466 }
26467
26468
26469 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26470 PyObject *resultobj = 0;
26471 wxIdleMode result;
26472
26473 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26474 {
26475 PyThreadState* __tstate = wxPyBeginAllowThreads();
26476 result = (wxIdleMode)wxIdleEvent::GetMode();
26477 wxPyEndAllowThreads(__tstate);
26478 if (PyErr_Occurred()) SWIG_fail;
26479 }
26480 resultobj = SWIG_From_int(static_cast< int >(result));
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj = 0;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 bool result;
26491 void *argp1 = 0 ;
26492 int res1 = 0 ;
26493 PyObject * obj0 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "win", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26500 if (!SWIG_IsOK(res1)) {
26501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26502 }
26503 arg1 = reinterpret_cast< wxWindow * >(argp1);
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 result = (bool)wxIdleEvent::CanSend(arg1);
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 {
26511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26512 }
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *obj;
26521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26522 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26523 return SWIG_Py_Void();
26524 }
26525
26526 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26527 return SWIG_Python_InitShadowInstance(args);
26528 }
26529
26530 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj = 0;
26532 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26533 int arg2 = (int) 0 ;
26534 wxClipboardTextEvent *result = 0 ;
26535 int val1 ;
26536 int ecode1 = 0 ;
26537 int val2 ;
26538 int ecode2 = 0 ;
26539 PyObject * obj0 = 0 ;
26540 PyObject * obj1 = 0 ;
26541 char * kwnames[] = {
26542 (char *) "type",(char *) "winid", NULL
26543 };
26544
26545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26546 if (obj0) {
26547 ecode1 = SWIG_AsVal_int(obj0, &val1);
26548 if (!SWIG_IsOK(ecode1)) {
26549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26550 }
26551 arg1 = static_cast< wxEventType >(val1);
26552 }
26553 if (obj1) {
26554 ecode2 = SWIG_AsVal_int(obj1, &val2);
26555 if (!SWIG_IsOK(ecode2)) {
26556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26557 }
26558 arg2 = static_cast< int >(val2);
26559 }
26560 {
26561 PyThreadState* __tstate = wxPyBeginAllowThreads();
26562 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26563 wxPyEndAllowThreads(__tstate);
26564 if (PyErr_Occurred()) SWIG_fail;
26565 }
26566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26567 return resultobj;
26568 fail:
26569 return NULL;
26570 }
26571
26572
26573 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26574 PyObject *obj;
26575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26576 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26577 return SWIG_Py_Void();
26578 }
26579
26580 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 return SWIG_Python_InitShadowInstance(args);
26582 }
26583
26584 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26585 PyObject *resultobj = 0;
26586 int arg1 = (int) 0 ;
26587 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26588 wxPyEvent *result = 0 ;
26589 int val1 ;
26590 int ecode1 = 0 ;
26591 int val2 ;
26592 int ecode2 = 0 ;
26593 PyObject * obj0 = 0 ;
26594 PyObject * obj1 = 0 ;
26595 char * kwnames[] = {
26596 (char *) "winid",(char *) "eventType", NULL
26597 };
26598
26599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26600 if (obj0) {
26601 ecode1 = SWIG_AsVal_int(obj0, &val1);
26602 if (!SWIG_IsOK(ecode1)) {
26603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26604 }
26605 arg1 = static_cast< int >(val1);
26606 }
26607 if (obj1) {
26608 ecode2 = SWIG_AsVal_int(obj1, &val2);
26609 if (!SWIG_IsOK(ecode2)) {
26610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26611 }
26612 arg2 = static_cast< wxEventType >(val2);
26613 }
26614 {
26615 PyThreadState* __tstate = wxPyBeginAllowThreads();
26616 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26617 wxPyEndAllowThreads(__tstate);
26618 if (PyErr_Occurred()) SWIG_fail;
26619 }
26620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26621 return resultobj;
26622 fail:
26623 return NULL;
26624 }
26625
26626
26627 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26628 PyObject *resultobj = 0;
26629 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26630 void *argp1 = 0 ;
26631 int res1 = 0 ;
26632 PyObject *swig_obj[1] ;
26633
26634 if (!args) SWIG_fail;
26635 swig_obj[0] = args;
26636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26637 if (!SWIG_IsOK(res1)) {
26638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26639 }
26640 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 delete arg1;
26644
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_Py_Void();
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj = 0;
26657 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26658 PyObject *arg2 = (PyObject *) 0 ;
26659 void *argp1 = 0 ;
26660 int res1 = 0 ;
26661 PyObject * obj0 = 0 ;
26662 PyObject * obj1 = 0 ;
26663 char * kwnames[] = {
26664 (char *) "self",(char *) "self", NULL
26665 };
26666
26667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26671 }
26672 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26673 arg2 = obj1;
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 (arg1)->SetSelf(arg2);
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 resultobj = SWIG_Py_Void();
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26688 PyObject *resultobj = 0;
26689 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26690 PyObject *result = 0 ;
26691 void *argp1 = 0 ;
26692 int res1 = 0 ;
26693 PyObject *swig_obj[1] ;
26694
26695 if (!args) SWIG_fail;
26696 swig_obj[0] = args;
26697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26698 if (!SWIG_IsOK(res1)) {
26699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26700 }
26701 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 result = (PyObject *)(arg1)->GetSelf();
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = result;
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 PyObject *obj;
26717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26718 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26719 return SWIG_Py_Void();
26720 }
26721
26722 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26723 return SWIG_Python_InitShadowInstance(args);
26724 }
26725
26726 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26727 PyObject *resultobj = 0;
26728 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26729 int arg2 = (int) 0 ;
26730 wxPyCommandEvent *result = 0 ;
26731 int val1 ;
26732 int ecode1 = 0 ;
26733 int val2 ;
26734 int ecode2 = 0 ;
26735 PyObject * obj0 = 0 ;
26736 PyObject * obj1 = 0 ;
26737 char * kwnames[] = {
26738 (char *) "eventType",(char *) "id", NULL
26739 };
26740
26741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26742 if (obj0) {
26743 ecode1 = SWIG_AsVal_int(obj0, &val1);
26744 if (!SWIG_IsOK(ecode1)) {
26745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26746 }
26747 arg1 = static_cast< wxEventType >(val1);
26748 }
26749 if (obj1) {
26750 ecode2 = SWIG_AsVal_int(obj1, &val2);
26751 if (!SWIG_IsOK(ecode2)) {
26752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26753 }
26754 arg2 = static_cast< int >(val2);
26755 }
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *resultobj = 0;
26771 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26772 void *argp1 = 0 ;
26773 int res1 = 0 ;
26774 PyObject *swig_obj[1] ;
26775
26776 if (!args) SWIG_fail;
26777 swig_obj[0] = args;
26778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26781 }
26782 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26783 {
26784 PyThreadState* __tstate = wxPyBeginAllowThreads();
26785 delete arg1;
26786
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_Py_Void();
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26798 PyObject *resultobj = 0;
26799 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26800 PyObject *arg2 = (PyObject *) 0 ;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 PyObject * obj0 = 0 ;
26804 PyObject * obj1 = 0 ;
26805 char * kwnames[] = {
26806 (char *) "self",(char *) "self", NULL
26807 };
26808
26809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26811 if (!SWIG_IsOK(res1)) {
26812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26813 }
26814 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26815 arg2 = obj1;
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 (arg1)->SetSelf(arg2);
26819 wxPyEndAllowThreads(__tstate);
26820 if (PyErr_Occurred()) SWIG_fail;
26821 }
26822 resultobj = SWIG_Py_Void();
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26830 PyObject *resultobj = 0;
26831 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26832 PyObject *result = 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 PyObject *swig_obj[1] ;
26836
26837 if (!args) SWIG_fail;
26838 swig_obj[0] = args;
26839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26840 if (!SWIG_IsOK(res1)) {
26841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26842 }
26843 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 result = (PyObject *)(arg1)->GetSelf();
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 resultobj = result;
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26858 PyObject *obj;
26859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26860 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26861 return SWIG_Py_Void();
26862 }
26863
26864 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26865 return SWIG_Python_InitShadowInstance(args);
26866 }
26867
26868 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj = 0;
26870 wxWindow *arg1 = (wxWindow *) 0 ;
26871 wxDateTime *arg2 = 0 ;
26872 wxEventType arg3 ;
26873 wxDateEvent *result = 0 ;
26874 void *argp1 = 0 ;
26875 int res1 = 0 ;
26876 void *argp2 = 0 ;
26877 int res2 = 0 ;
26878 int val3 ;
26879 int ecode3 = 0 ;
26880 PyObject * obj0 = 0 ;
26881 PyObject * obj1 = 0 ;
26882 PyObject * obj2 = 0 ;
26883 char * kwnames[] = {
26884 (char *) "win",(char *) "dt",(char *) "type", NULL
26885 };
26886
26887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26889 if (!SWIG_IsOK(res1)) {
26890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26891 }
26892 arg1 = reinterpret_cast< wxWindow * >(argp1);
26893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26894 if (!SWIG_IsOK(res2)) {
26895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26896 }
26897 if (!argp2) {
26898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26899 }
26900 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26901 ecode3 = SWIG_AsVal_int(obj2, &val3);
26902 if (!SWIG_IsOK(ecode3)) {
26903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26904 }
26905 arg3 = static_cast< wxEventType >(val3);
26906 {
26907 PyThreadState* __tstate = wxPyBeginAllowThreads();
26908 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26909 wxPyEndAllowThreads(__tstate);
26910 if (PyErr_Occurred()) SWIG_fail;
26911 }
26912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26913 return resultobj;
26914 fail:
26915 return NULL;
26916 }
26917
26918
26919 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26920 PyObject *resultobj = 0;
26921 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26922 wxDateTime *result = 0 ;
26923 void *argp1 = 0 ;
26924 int res1 = 0 ;
26925 PyObject *swig_obj[1] ;
26926
26927 if (!args) SWIG_fail;
26928 swig_obj[0] = args;
26929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26930 if (!SWIG_IsOK(res1)) {
26931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26932 }
26933 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 {
26937 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26938 result = (wxDateTime *) &_result_ref;
26939 }
26940 wxPyEndAllowThreads(__tstate);
26941 if (PyErr_Occurred()) SWIG_fail;
26942 }
26943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26944 return resultobj;
26945 fail:
26946 return NULL;
26947 }
26948
26949
26950 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26951 PyObject *resultobj = 0;
26952 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26953 wxDateTime *arg2 = 0 ;
26954 void *argp1 = 0 ;
26955 int res1 = 0 ;
26956 void *argp2 = 0 ;
26957 int res2 = 0 ;
26958 PyObject * obj0 = 0 ;
26959 PyObject * obj1 = 0 ;
26960 char * kwnames[] = {
26961 (char *) "self",(char *) "date", NULL
26962 };
26963
26964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26966 if (!SWIG_IsOK(res1)) {
26967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26968 }
26969 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26971 if (!SWIG_IsOK(res2)) {
26972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26973 }
26974 if (!argp2) {
26975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26976 }
26977 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 (arg1)->SetDate((wxDateTime const &)*arg2);
26981 wxPyEndAllowThreads(__tstate);
26982 if (PyErr_Occurred()) SWIG_fail;
26983 }
26984 resultobj = SWIG_Py_Void();
26985 return resultobj;
26986 fail:
26987 return NULL;
26988 }
26989
26990
26991 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26992 PyObject *obj;
26993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26994 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26995 return SWIG_Py_Void();
26996 }
26997
26998 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26999 return SWIG_Python_InitShadowInstance(args);
27000 }
27001
27002 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27003 PyObject *resultobj = 0;
27004 wxPyApp *result = 0 ;
27005
27006 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 result = (wxPyApp *)new_wxPyApp();
27010 wxPyEndAllowThreads(__tstate);
27011 if (PyErr_Occurred()) SWIG_fail;
27012 }
27013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27014 return resultobj;
27015 fail:
27016 return NULL;
27017 }
27018
27019
27020 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27021 PyObject *resultobj = 0;
27022 wxPyApp *arg1 = (wxPyApp *) 0 ;
27023 void *argp1 = 0 ;
27024 int res1 = 0 ;
27025 PyObject *swig_obj[1] ;
27026
27027 if (!args) SWIG_fail;
27028 swig_obj[0] = args;
27029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27030 if (!SWIG_IsOK(res1)) {
27031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27032 }
27033 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27034 {
27035 PyThreadState* __tstate = wxPyBeginAllowThreads();
27036 delete arg1;
27037
27038 wxPyEndAllowThreads(__tstate);
27039 if (PyErr_Occurred()) SWIG_fail;
27040 }
27041 resultobj = SWIG_Py_Void();
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxPyApp *arg1 = (wxPyApp *) 0 ;
27051 PyObject *arg2 = (PyObject *) 0 ;
27052 PyObject *arg3 = (PyObject *) 0 ;
27053 bool arg4 ;
27054 void *argp1 = 0 ;
27055 int res1 = 0 ;
27056 bool val4 ;
27057 int ecode4 = 0 ;
27058 PyObject * obj0 = 0 ;
27059 PyObject * obj1 = 0 ;
27060 PyObject * obj2 = 0 ;
27061 PyObject * obj3 = 0 ;
27062 char * kwnames[] = {
27063 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27064 };
27065
27066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27068 if (!SWIG_IsOK(res1)) {
27069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27070 }
27071 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27072 arg2 = obj1;
27073 arg3 = obj2;
27074 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27075 if (!SWIG_IsOK(ecode4)) {
27076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27077 }
27078 arg4 = static_cast< bool >(val4);
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 resultobj = SWIG_Py_Void();
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27093 PyObject *resultobj = 0;
27094 wxPyApp *arg1 = (wxPyApp *) 0 ;
27095 wxString result;
27096 void *argp1 = 0 ;
27097 int res1 = 0 ;
27098 PyObject *swig_obj[1] ;
27099
27100 if (!args) SWIG_fail;
27101 swig_obj[0] = args;
27102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27103 if (!SWIG_IsOK(res1)) {
27104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27105 }
27106 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27107 {
27108 PyThreadState* __tstate = wxPyBeginAllowThreads();
27109 result = ((wxPyApp const *)arg1)->GetAppName();
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 {
27114 #if wxUSE_UNICODE
27115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27116 #else
27117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27118 #endif
27119 }
27120 return resultobj;
27121 fail:
27122 return NULL;
27123 }
27124
27125
27126 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27127 PyObject *resultobj = 0;
27128 wxPyApp *arg1 = (wxPyApp *) 0 ;
27129 wxString *arg2 = 0 ;
27130 void *argp1 = 0 ;
27131 int res1 = 0 ;
27132 bool temp2 = false ;
27133 PyObject * obj0 = 0 ;
27134 PyObject * obj1 = 0 ;
27135 char * kwnames[] = {
27136 (char *) "self",(char *) "name", NULL
27137 };
27138
27139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27141 if (!SWIG_IsOK(res1)) {
27142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27143 }
27144 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27145 {
27146 arg2 = wxString_in_helper(obj1);
27147 if (arg2 == NULL) SWIG_fail;
27148 temp2 = true;
27149 }
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 (arg1)->SetAppName((wxString const &)*arg2);
27153 wxPyEndAllowThreads(__tstate);
27154 if (PyErr_Occurred()) SWIG_fail;
27155 }
27156 resultobj = SWIG_Py_Void();
27157 {
27158 if (temp2)
27159 delete arg2;
27160 }
27161 return resultobj;
27162 fail:
27163 {
27164 if (temp2)
27165 delete arg2;
27166 }
27167 return NULL;
27168 }
27169
27170
27171 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27172 PyObject *resultobj = 0;
27173 wxPyApp *arg1 = (wxPyApp *) 0 ;
27174 wxString result;
27175 void *argp1 = 0 ;
27176 int res1 = 0 ;
27177 PyObject *swig_obj[1] ;
27178
27179 if (!args) SWIG_fail;
27180 swig_obj[0] = args;
27181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27182 if (!SWIG_IsOK(res1)) {
27183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27184 }
27185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 result = ((wxPyApp const *)arg1)->GetClassName();
27189 wxPyEndAllowThreads(__tstate);
27190 if (PyErr_Occurred()) SWIG_fail;
27191 }
27192 {
27193 #if wxUSE_UNICODE
27194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27195 #else
27196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27197 #endif
27198 }
27199 return resultobj;
27200 fail:
27201 return NULL;
27202 }
27203
27204
27205 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27206 PyObject *resultobj = 0;
27207 wxPyApp *arg1 = (wxPyApp *) 0 ;
27208 wxString *arg2 = 0 ;
27209 void *argp1 = 0 ;
27210 int res1 = 0 ;
27211 bool temp2 = false ;
27212 PyObject * obj0 = 0 ;
27213 PyObject * obj1 = 0 ;
27214 char * kwnames[] = {
27215 (char *) "self",(char *) "name", NULL
27216 };
27217
27218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27220 if (!SWIG_IsOK(res1)) {
27221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27222 }
27223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27224 {
27225 arg2 = wxString_in_helper(obj1);
27226 if (arg2 == NULL) SWIG_fail;
27227 temp2 = true;
27228 }
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 (arg1)->SetClassName((wxString const &)*arg2);
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 resultobj = SWIG_Py_Void();
27236 {
27237 if (temp2)
27238 delete arg2;
27239 }
27240 return resultobj;
27241 fail:
27242 {
27243 if (temp2)
27244 delete arg2;
27245 }
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27251 PyObject *resultobj = 0;
27252 wxPyApp *arg1 = (wxPyApp *) 0 ;
27253 wxString *result = 0 ;
27254 void *argp1 = 0 ;
27255 int res1 = 0 ;
27256 PyObject *swig_obj[1] ;
27257
27258 if (!args) SWIG_fail;
27259 swig_obj[0] = args;
27260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27261 if (!SWIG_IsOK(res1)) {
27262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27263 }
27264 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 {
27268 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27269 result = (wxString *) &_result_ref;
27270 }
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 {
27275 #if wxUSE_UNICODE
27276 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27277 #else
27278 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27279 #endif
27280 }
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj = 0;
27289 wxPyApp *arg1 = (wxPyApp *) 0 ;
27290 wxString *arg2 = 0 ;
27291 void *argp1 = 0 ;
27292 int res1 = 0 ;
27293 bool temp2 = false ;
27294 PyObject * obj0 = 0 ;
27295 PyObject * obj1 = 0 ;
27296 char * kwnames[] = {
27297 (char *) "self",(char *) "name", NULL
27298 };
27299
27300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27302 if (!SWIG_IsOK(res1)) {
27303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27304 }
27305 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27306 {
27307 arg2 = wxString_in_helper(obj1);
27308 if (arg2 == NULL) SWIG_fail;
27309 temp2 = true;
27310 }
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 (arg1)->SetVendorName((wxString const &)*arg2);
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 resultobj = SWIG_Py_Void();
27318 {
27319 if (temp2)
27320 delete arg2;
27321 }
27322 return resultobj;
27323 fail:
27324 {
27325 if (temp2)
27326 delete arg2;
27327 }
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxPyApp *arg1 = (wxPyApp *) 0 ;
27335 wxAppTraits *result = 0 ;
27336 void *argp1 = 0 ;
27337 int res1 = 0 ;
27338 PyObject *swig_obj[1] ;
27339
27340 if (!args) SWIG_fail;
27341 swig_obj[0] = args;
27342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27345 }
27346 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27347 {
27348 PyThreadState* __tstate = wxPyBeginAllowThreads();
27349 result = (wxAppTraits *)(arg1)->GetTraits();
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27361 PyObject *resultobj = 0;
27362 wxPyApp *arg1 = (wxPyApp *) 0 ;
27363 void *argp1 = 0 ;
27364 int res1 = 0 ;
27365 PyObject *swig_obj[1] ;
27366
27367 if (!args) SWIG_fail;
27368 swig_obj[0] = args;
27369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27370 if (!SWIG_IsOK(res1)) {
27371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27372 }
27373 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->ProcessPendingEvents();
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_Py_Void();
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj = 0;
27389 wxPyApp *arg1 = (wxPyApp *) 0 ;
27390 bool arg2 = (bool) false ;
27391 bool result;
27392 void *argp1 = 0 ;
27393 int res1 = 0 ;
27394 bool val2 ;
27395 int ecode2 = 0 ;
27396 PyObject * obj0 = 0 ;
27397 PyObject * obj1 = 0 ;
27398 char * kwnames[] = {
27399 (char *) "self",(char *) "onlyIfNeeded", NULL
27400 };
27401
27402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27404 if (!SWIG_IsOK(res1)) {
27405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27406 }
27407 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27408 if (obj1) {
27409 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27410 if (!SWIG_IsOK(ecode2)) {
27411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27412 }
27413 arg2 = static_cast< bool >(val2);
27414 }
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 result = (bool)(arg1)->Yield(arg2);
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 {
27422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27442 }
27443 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 (arg1)->WakeUpIdle();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = SWIG_Py_Void();
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27458 PyObject *resultobj = 0;
27459 bool result;
27460
27461 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 result = (bool)wxPyApp::IsMainLoopRunning();
27465 wxPyEndAllowThreads(__tstate);
27466 if (PyErr_Occurred()) SWIG_fail;
27467 }
27468 {
27469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27470 }
27471 return resultobj;
27472 fail:
27473 return NULL;
27474 }
27475
27476
27477 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27478 PyObject *resultobj = 0;
27479 wxPyApp *arg1 = (wxPyApp *) 0 ;
27480 int result;
27481 void *argp1 = 0 ;
27482 int res1 = 0 ;
27483 PyObject *swig_obj[1] ;
27484
27485 if (!args) SWIG_fail;
27486 swig_obj[0] = args;
27487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27488 if (!SWIG_IsOK(res1)) {
27489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27490 }
27491 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27492 {
27493 PyThreadState* __tstate = wxPyBeginAllowThreads();
27494 result = (int)(arg1)->MainLoop();
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 resultobj = SWIG_From_int(static_cast< int >(result));
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506 PyObject *resultobj = 0;
27507 wxPyApp *arg1 = (wxPyApp *) 0 ;
27508 void *argp1 = 0 ;
27509 int res1 = 0 ;
27510 PyObject *swig_obj[1] ;
27511
27512 if (!args) SWIG_fail;
27513 swig_obj[0] = args;
27514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27515 if (!SWIG_IsOK(res1)) {
27516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27517 }
27518 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27519 {
27520 PyThreadState* __tstate = wxPyBeginAllowThreads();
27521 (arg1)->Exit();
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 resultobj = SWIG_Py_Void();
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27533 PyObject *resultobj = 0;
27534 wxPyApp *arg1 = (wxPyApp *) 0 ;
27535 void *argp1 = 0 ;
27536 int res1 = 0 ;
27537 PyObject *swig_obj[1] ;
27538
27539 if (!args) SWIG_fail;
27540 swig_obj[0] = args;
27541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27542 if (!SWIG_IsOK(res1)) {
27543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27544 }
27545 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 (arg1)->ExitMainLoop();
27549 wxPyEndAllowThreads(__tstate);
27550 if (PyErr_Occurred()) SWIG_fail;
27551 }
27552 resultobj = SWIG_Py_Void();
27553 return resultobj;
27554 fail:
27555 return NULL;
27556 }
27557
27558
27559 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27560 PyObject *resultobj = 0;
27561 wxPyApp *arg1 = (wxPyApp *) 0 ;
27562 bool result;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 PyObject *swig_obj[1] ;
27566
27567 if (!args) SWIG_fail;
27568 swig_obj[0] = args;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27572 }
27573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 result = (bool)(arg1)->Pending();
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 {
27581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27582 }
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27590 PyObject *resultobj = 0;
27591 wxPyApp *arg1 = (wxPyApp *) 0 ;
27592 bool result;
27593 void *argp1 = 0 ;
27594 int res1 = 0 ;
27595 PyObject *swig_obj[1] ;
27596
27597 if (!args) SWIG_fail;
27598 swig_obj[0] = args;
27599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27600 if (!SWIG_IsOK(res1)) {
27601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27602 }
27603 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 result = (bool)(arg1)->Dispatch();
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 {
27611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27612 }
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27620 PyObject *resultobj = 0;
27621 wxPyApp *arg1 = (wxPyApp *) 0 ;
27622 bool result;
27623 void *argp1 = 0 ;
27624 int res1 = 0 ;
27625 PyObject *swig_obj[1] ;
27626
27627 if (!args) SWIG_fail;
27628 swig_obj[0] = args;
27629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27630 if (!SWIG_IsOK(res1)) {
27631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27632 }
27633 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27634 {
27635 PyThreadState* __tstate = wxPyBeginAllowThreads();
27636 result = (bool)(arg1)->ProcessIdle();
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 {
27641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27642 }
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj = 0;
27651 wxPyApp *arg1 = (wxPyApp *) 0 ;
27652 wxWindow *arg2 = (wxWindow *) 0 ;
27653 wxIdleEvent *arg3 = 0 ;
27654 bool result;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 void *argp2 = 0 ;
27658 int res2 = 0 ;
27659 void *argp3 = 0 ;
27660 int res3 = 0 ;
27661 PyObject * obj0 = 0 ;
27662 PyObject * obj1 = 0 ;
27663 PyObject * obj2 = 0 ;
27664 char * kwnames[] = {
27665 (char *) "self",(char *) "win",(char *) "event", NULL
27666 };
27667
27668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27670 if (!SWIG_IsOK(res1)) {
27671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27672 }
27673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27675 if (!SWIG_IsOK(res2)) {
27676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27677 }
27678 arg2 = reinterpret_cast< wxWindow * >(argp2);
27679 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27680 if (!SWIG_IsOK(res3)) {
27681 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27682 }
27683 if (!argp3) {
27684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27685 }
27686 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27703 PyObject *resultobj = 0;
27704 wxPyApp *arg1 = (wxPyApp *) 0 ;
27705 bool result;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 PyObject *swig_obj[1] ;
27709
27710 if (!args) SWIG_fail;
27711 swig_obj[0] = args;
27712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (bool)((wxPyApp const *)arg1)->IsActive();
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 {
27724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27725 }
27726 return resultobj;
27727 fail:
27728 return NULL;
27729 }
27730
27731
27732 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27733 PyObject *resultobj = 0;
27734 wxPyApp *arg1 = (wxPyApp *) 0 ;
27735 wxWindow *arg2 = (wxWindow *) 0 ;
27736 void *argp1 = 0 ;
27737 int res1 = 0 ;
27738 void *argp2 = 0 ;
27739 int res2 = 0 ;
27740 PyObject * obj0 = 0 ;
27741 PyObject * obj1 = 0 ;
27742 char * kwnames[] = {
27743 (char *) "self",(char *) "win", NULL
27744 };
27745
27746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27748 if (!SWIG_IsOK(res1)) {
27749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27750 }
27751 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27753 if (!SWIG_IsOK(res2)) {
27754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27755 }
27756 arg2 = reinterpret_cast< wxWindow * >(argp2);
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 (arg1)->SetTopWindow(arg2);
27760 wxPyEndAllowThreads(__tstate);
27761 if (PyErr_Occurred()) SWIG_fail;
27762 }
27763 resultobj = SWIG_Py_Void();
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27771 PyObject *resultobj = 0;
27772 wxPyApp *arg1 = (wxPyApp *) 0 ;
27773 wxWindow *result = 0 ;
27774 void *argp1 = 0 ;
27775 int res1 = 0 ;
27776 PyObject *swig_obj[1] ;
27777
27778 if (!args) SWIG_fail;
27779 swig_obj[0] = args;
27780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27781 if (!SWIG_IsOK(res1)) {
27782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27783 }
27784 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 {
27792 resultobj = wxPyMake_wxObject(result, (bool)0);
27793 }
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj = 0;
27802 wxPyApp *arg1 = (wxPyApp *) 0 ;
27803 bool arg2 ;
27804 void *argp1 = 0 ;
27805 int res1 = 0 ;
27806 bool val2 ;
27807 int ecode2 = 0 ;
27808 PyObject * obj0 = 0 ;
27809 PyObject * obj1 = 0 ;
27810 char * kwnames[] = {
27811 (char *) "self",(char *) "flag", NULL
27812 };
27813
27814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27816 if (!SWIG_IsOK(res1)) {
27817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27818 }
27819 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27821 if (!SWIG_IsOK(ecode2)) {
27822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27823 }
27824 arg2 = static_cast< bool >(val2);
27825 {
27826 PyThreadState* __tstate = wxPyBeginAllowThreads();
27827 (arg1)->SetExitOnFrameDelete(arg2);
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 resultobj = SWIG_Py_Void();
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27839 PyObject *resultobj = 0;
27840 wxPyApp *arg1 = (wxPyApp *) 0 ;
27841 bool result;
27842 void *argp1 = 0 ;
27843 int res1 = 0 ;
27844 PyObject *swig_obj[1] ;
27845
27846 if (!args) SWIG_fail;
27847 swig_obj[0] = args;
27848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27849 if (!SWIG_IsOK(res1)) {
27850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27851 }
27852 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 {
27860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27861 }
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27869 PyObject *resultobj = 0;
27870 wxPyApp *arg1 = (wxPyApp *) 0 ;
27871 bool arg2 ;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 bool val2 ;
27875 int ecode2 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char * kwnames[] = {
27879 (char *) "self",(char *) "flag", NULL
27880 };
27881
27882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27884 if (!SWIG_IsOK(res1)) {
27885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27886 }
27887 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27889 if (!SWIG_IsOK(ecode2)) {
27890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27891 }
27892 arg2 = static_cast< bool >(val2);
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 (arg1)->SetUseBestVisual(arg2);
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 resultobj = SWIG_Py_Void();
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27907 PyObject *resultobj = 0;
27908 wxPyApp *arg1 = (wxPyApp *) 0 ;
27909 bool result;
27910 void *argp1 = 0 ;
27911 int res1 = 0 ;
27912 PyObject *swig_obj[1] ;
27913
27914 if (!args) SWIG_fail;
27915 swig_obj[0] = args;
27916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27917 if (!SWIG_IsOK(res1)) {
27918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27919 }
27920 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27924 wxPyEndAllowThreads(__tstate);
27925 if (PyErr_Occurred()) SWIG_fail;
27926 }
27927 {
27928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27929 }
27930 return resultobj;
27931 fail:
27932 return NULL;
27933 }
27934
27935
27936 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27937 PyObject *resultobj = 0;
27938 wxPyApp *arg1 = (wxPyApp *) 0 ;
27939 int arg2 ;
27940 void *argp1 = 0 ;
27941 int res1 = 0 ;
27942 int val2 ;
27943 int ecode2 = 0 ;
27944 PyObject * obj0 = 0 ;
27945 PyObject * obj1 = 0 ;
27946 char * kwnames[] = {
27947 (char *) "self",(char *) "mode", NULL
27948 };
27949
27950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27952 if (!SWIG_IsOK(res1)) {
27953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27954 }
27955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27956 ecode2 = SWIG_AsVal_int(obj1, &val2);
27957 if (!SWIG_IsOK(ecode2)) {
27958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27959 }
27960 arg2 = static_cast< int >(val2);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 (arg1)->SetPrintMode(arg2);
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 resultobj = SWIG_Py_Void();
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27975 PyObject *resultobj = 0;
27976 wxPyApp *arg1 = (wxPyApp *) 0 ;
27977 int result;
27978 void *argp1 = 0 ;
27979 int res1 = 0 ;
27980 PyObject *swig_obj[1] ;
27981
27982 if (!args) SWIG_fail;
27983 swig_obj[0] = args;
27984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27985 if (!SWIG_IsOK(res1)) {
27986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27987 }
27988 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_From_int(static_cast< int >(result));
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj = 0;
28004 wxPyApp *arg1 = (wxPyApp *) 0 ;
28005 int arg2 ;
28006 void *argp1 = 0 ;
28007 int res1 = 0 ;
28008 int val2 ;
28009 int ecode2 = 0 ;
28010 PyObject * obj0 = 0 ;
28011 PyObject * obj1 = 0 ;
28012 char * kwnames[] = {
28013 (char *) "self",(char *) "mode", NULL
28014 };
28015
28016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28018 if (!SWIG_IsOK(res1)) {
28019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28020 }
28021 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28022 ecode2 = SWIG_AsVal_int(obj1, &val2);
28023 if (!SWIG_IsOK(ecode2)) {
28024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28025 }
28026 arg2 = static_cast< int >(val2);
28027 {
28028 PyThreadState* __tstate = wxPyBeginAllowThreads();
28029 (arg1)->SetAssertMode(arg2);
28030 wxPyEndAllowThreads(__tstate);
28031 if (PyErr_Occurred()) SWIG_fail;
28032 }
28033 resultobj = SWIG_Py_Void();
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28041 PyObject *resultobj = 0;
28042 wxPyApp *arg1 = (wxPyApp *) 0 ;
28043 int result;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 PyObject *swig_obj[1] ;
28047
28048 if (!args) SWIG_fail;
28049 swig_obj[0] = args;
28050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28051 if (!SWIG_IsOK(res1)) {
28052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28053 }
28054 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 result = (int)(arg1)->GetAssertMode();
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_From_int(static_cast< int >(result));
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28069 PyObject *resultobj = 0;
28070 bool result;
28071
28072 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 {
28080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28081 }
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28089 PyObject *resultobj = 0;
28090 long result;
28091
28092 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 result = (long)wxPyApp::GetMacAboutMenuItemId();
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_From_long(static_cast< long >(result));
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28107 PyObject *resultobj = 0;
28108 long result;
28109
28110 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 resultobj = SWIG_From_long(static_cast< long >(result));
28118 return resultobj;
28119 fail:
28120 return NULL;
28121 }
28122
28123
28124 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28125 PyObject *resultobj = 0;
28126 long result;
28127
28128 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (long)wxPyApp::GetMacExitMenuItemId();
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = SWIG_From_long(static_cast< long >(result));
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28143 PyObject *resultobj = 0;
28144 wxString result;
28145
28146 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = wxPyApp::GetMacHelpMenuTitleName();
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 #if wxUSE_UNICODE
28155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28156 #else
28157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28158 #endif
28159 }
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj = 0;
28168 bool arg1 ;
28169 bool val1 ;
28170 int ecode1 = 0 ;
28171 PyObject * obj0 = 0 ;
28172 char * kwnames[] = {
28173 (char *) "val", NULL
28174 };
28175
28176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28177 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28178 if (!SWIG_IsOK(ecode1)) {
28179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28180 }
28181 arg1 = static_cast< bool >(val1);
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28185 wxPyEndAllowThreads(__tstate);
28186 if (PyErr_Occurred()) SWIG_fail;
28187 }
28188 resultobj = SWIG_Py_Void();
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj = 0;
28197 long arg1 ;
28198 long val1 ;
28199 int ecode1 = 0 ;
28200 PyObject * obj0 = 0 ;
28201 char * kwnames[] = {
28202 (char *) "val", NULL
28203 };
28204
28205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28206 ecode1 = SWIG_AsVal_long(obj0, &val1);
28207 if (!SWIG_IsOK(ecode1)) {
28208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28209 }
28210 arg1 = static_cast< long >(val1);
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 wxPyApp::SetMacAboutMenuItemId(arg1);
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 resultobj = SWIG_Py_Void();
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj = 0;
28226 long arg1 ;
28227 long val1 ;
28228 int ecode1 = 0 ;
28229 PyObject * obj0 = 0 ;
28230 char * kwnames[] = {
28231 (char *) "val", NULL
28232 };
28233
28234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28235 ecode1 = SWIG_AsVal_long(obj0, &val1);
28236 if (!SWIG_IsOK(ecode1)) {
28237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28238 }
28239 arg1 = static_cast< long >(val1);
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 resultobj = SWIG_Py_Void();
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28254 PyObject *resultobj = 0;
28255 long arg1 ;
28256 long val1 ;
28257 int ecode1 = 0 ;
28258 PyObject * obj0 = 0 ;
28259 char * kwnames[] = {
28260 (char *) "val", NULL
28261 };
28262
28263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28264 ecode1 = SWIG_AsVal_long(obj0, &val1);
28265 if (!SWIG_IsOK(ecode1)) {
28266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28267 }
28268 arg1 = static_cast< long >(val1);
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 wxPyApp::SetMacExitMenuItemId(arg1);
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_Py_Void();
28276 return resultobj;
28277 fail:
28278 return NULL;
28279 }
28280
28281
28282 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 wxString *arg1 = 0 ;
28285 bool temp1 = false ;
28286 PyObject * obj0 = 0 ;
28287 char * kwnames[] = {
28288 (char *) "val", NULL
28289 };
28290
28291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28292 {
28293 arg1 = wxString_in_helper(obj0);
28294 if (arg1 == NULL) SWIG_fail;
28295 temp1 = true;
28296 }
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 resultobj = SWIG_Py_Void();
28304 {
28305 if (temp1)
28306 delete arg1;
28307 }
28308 return resultobj;
28309 fail:
28310 {
28311 if (temp1)
28312 delete arg1;
28313 }
28314 return NULL;
28315 }
28316
28317
28318 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28319 PyObject *resultobj = 0;
28320 wxPyApp *arg1 = (wxPyApp *) 0 ;
28321 void *argp1 = 0 ;
28322 int res1 = 0 ;
28323 PyObject *swig_obj[1] ;
28324
28325 if (!args) SWIG_fail;
28326 swig_obj[0] = args;
28327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28328 if (!SWIG_IsOK(res1)) {
28329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28330 }
28331 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28332 {
28333 PyThreadState* __tstate = wxPyBeginAllowThreads();
28334 (arg1)->_BootstrapApp();
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 resultobj = SWIG_Py_Void();
28339 return resultobj;
28340 fail:
28341 return NULL;
28342 }
28343
28344
28345 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28346 PyObject *resultobj = 0;
28347 int result;
28348
28349 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28350 {
28351 PyThreadState* __tstate = wxPyBeginAllowThreads();
28352 result = (int)wxPyApp_GetComCtl32Version();
28353 wxPyEndAllowThreads(__tstate);
28354 if (PyErr_Occurred()) SWIG_fail;
28355 }
28356 resultobj = SWIG_From_int(static_cast< int >(result));
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28364 PyObject *obj;
28365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28366 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28367 return SWIG_Py_Void();
28368 }
28369
28370 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28371 return SWIG_Python_InitShadowInstance(args);
28372 }
28373
28374 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376
28377 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 wxExit();
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_Py_Void();
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 bool result;
28394
28395 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (bool)wxYield();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 {
28403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28404 }
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28412 PyObject *resultobj = 0;
28413 bool result;
28414
28415 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)wxYieldIfNeeded();
28419 wxPyEndAllowThreads(__tstate);
28420 if (PyErr_Occurred()) SWIG_fail;
28421 }
28422 {
28423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28424 }
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj = 0;
28433 wxWindow *arg1 = (wxWindow *) NULL ;
28434 bool arg2 = (bool) false ;
28435 bool result;
28436 void *argp1 = 0 ;
28437 int res1 = 0 ;
28438 bool val2 ;
28439 int ecode2 = 0 ;
28440 PyObject * obj0 = 0 ;
28441 PyObject * obj1 = 0 ;
28442 char * kwnames[] = {
28443 (char *) "win",(char *) "onlyIfNeeded", NULL
28444 };
28445
28446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28447 if (obj0) {
28448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28451 }
28452 arg1 = reinterpret_cast< wxWindow * >(argp1);
28453 }
28454 if (obj1) {
28455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28456 if (!SWIG_IsOK(ecode2)) {
28457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28458 }
28459 arg2 = static_cast< bool >(val2);
28460 }
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (bool)wxSafeYield(arg1,arg2);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 {
28468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28469 }
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28477 PyObject *resultobj = 0;
28478
28479 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 wxWakeUpIdle();
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_Py_Void();
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28494 PyObject *resultobj = 0;
28495 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28496 wxEvent *arg2 = 0 ;
28497 void *argp1 = 0 ;
28498 int res1 = 0 ;
28499 void *argp2 = 0 ;
28500 int res2 = 0 ;
28501 PyObject * obj0 = 0 ;
28502 PyObject * obj1 = 0 ;
28503 char * kwnames[] = {
28504 (char *) "dest",(char *) "event", NULL
28505 };
28506
28507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28511 }
28512 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28513 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28514 if (!SWIG_IsOK(res2)) {
28515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28516 }
28517 if (!argp2) {
28518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28519 }
28520 arg2 = reinterpret_cast< wxEvent * >(argp2);
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 wxPostEvent(arg1,*arg2);
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 resultobj = SWIG_Py_Void();
28528 return resultobj;
28529 fail:
28530 return NULL;
28531 }
28532
28533
28534 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28535 PyObject *resultobj = 0;
28536
28537 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 wxApp_CleanUp();
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_Py_Void();
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28552 PyObject *resultobj = 0;
28553 wxPyApp *result = 0 ;
28554
28555 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (wxPyApp *)wxPyGetApp();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 {
28563 resultobj = wxPyMake_wxObject(result, 0);
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj = 0;
28573 char *arg1 = (char *) 0 ;
28574 int res1 ;
28575 char *buf1 = 0 ;
28576 int alloc1 = 0 ;
28577 PyObject * obj0 = 0 ;
28578 char * kwnames[] = {
28579 (char *) "encoding", NULL
28580 };
28581
28582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28583 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28586 }
28587 arg1 = buf1;
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 wxSetDefaultPyEncoding((char const *)arg1);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 resultobj = SWIG_Py_Void();
28595 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28596 return resultobj;
28597 fail:
28598 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *resultobj = 0;
28605 char *result = 0 ;
28606
28607 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 result = (char *)wxGetDefaultPyEncoding();
28611 wxPyEndAllowThreads(__tstate);
28612 if (PyErr_Occurred()) SWIG_fail;
28613 }
28614 resultobj = SWIG_FromCharPtr(result);
28615 return resultobj;
28616 fail:
28617 return NULL;
28618 }
28619
28620
28621 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28622 PyObject *resultobj = 0;
28623 wxEventLoop *result = 0 ;
28624
28625 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (wxEventLoop *)new wxEventLoop();
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28640 PyObject *resultobj = 0;
28641 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28642 void *argp1 = 0 ;
28643 int res1 = 0 ;
28644 PyObject *swig_obj[1] ;
28645
28646 if (!args) SWIG_fail;
28647 swig_obj[0] = args;
28648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28649 if (!SWIG_IsOK(res1)) {
28650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28651 }
28652 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28653 {
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 delete arg1;
28656
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_Py_Void();
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28670 int result;
28671 void *argp1 = 0 ;
28672 int res1 = 0 ;
28673 PyObject *swig_obj[1] ;
28674
28675 if (!args) SWIG_fail;
28676 swig_obj[0] = args;
28677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28680 }
28681 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 result = (int)(arg1)->Run();
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 resultobj = SWIG_From_int(static_cast< int >(result));
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj = 0;
28697 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28698 int arg2 = (int) 0 ;
28699 void *argp1 = 0 ;
28700 int res1 = 0 ;
28701 int val2 ;
28702 int ecode2 = 0 ;
28703 PyObject * obj0 = 0 ;
28704 PyObject * obj1 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "self",(char *) "rc", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28713 }
28714 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28715 if (obj1) {
28716 ecode2 = SWIG_AsVal_int(obj1, &val2);
28717 if (!SWIG_IsOK(ecode2)) {
28718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28719 }
28720 arg2 = static_cast< int >(val2);
28721 }
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 (arg1)->Exit(arg2);
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_Py_Void();
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28736 PyObject *resultobj = 0;
28737 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28738 bool result;
28739 void *argp1 = 0 ;
28740 int res1 = 0 ;
28741 PyObject *swig_obj[1] ;
28742
28743 if (!args) SWIG_fail;
28744 swig_obj[0] = args;
28745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28746 if (!SWIG_IsOK(res1)) {
28747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28748 }
28749 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (bool)((wxEventLoop const *)arg1)->Pending();
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28766 PyObject *resultobj = 0;
28767 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28768 bool result;
28769 void *argp1 = 0 ;
28770 int res1 = 0 ;
28771 PyObject *swig_obj[1] ;
28772
28773 if (!args) SWIG_fail;
28774 swig_obj[0] = args;
28775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28776 if (!SWIG_IsOK(res1)) {
28777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28778 }
28779 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (bool)(arg1)->Dispatch();
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 {
28787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28788 }
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28798 bool result;
28799 void *argp1 = 0 ;
28800 int res1 = 0 ;
28801 PyObject *swig_obj[1] ;
28802
28803 if (!args) SWIG_fail;
28804 swig_obj[0] = args;
28805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28808 }
28809 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 {
28817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28818 }
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28826 PyObject *resultobj = 0;
28827 wxEventLoop *result = 0 ;
28828
28829 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 result = (wxEventLoop *)wxEventLoop::GetActive();
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28846 void *argp1 = 0 ;
28847 int res1 = 0 ;
28848 PyObject * obj0 = 0 ;
28849 char * kwnames[] = {
28850 (char *) "loop", NULL
28851 };
28852
28853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28855 if (!SWIG_IsOK(res1)) {
28856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28857 }
28858 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 wxEventLoop::SetActive(arg1);
28862 wxPyEndAllowThreads(__tstate);
28863 if (PyErr_Occurred()) SWIG_fail;
28864 }
28865 resultobj = SWIG_Py_Void();
28866 return resultobj;
28867 fail:
28868 return NULL;
28869 }
28870
28871
28872 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28873 PyObject *obj;
28874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28875 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28876 return SWIG_Py_Void();
28877 }
28878
28879 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 return SWIG_Python_InitShadowInstance(args);
28881 }
28882
28883 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj = 0;
28885 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28886 wxEventLoopActivator *result = 0 ;
28887 void *argp1 = 0 ;
28888 int res1 = 0 ;
28889 PyObject * obj0 = 0 ;
28890 char * kwnames[] = {
28891 (char *) "evtLoop", NULL
28892 };
28893
28894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28896 if (!SWIG_IsOK(res1)) {
28897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28898 }
28899 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 PyObject *resultobj = 0;
28915 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28916 void *argp1 = 0 ;
28917 int res1 = 0 ;
28918 PyObject *swig_obj[1] ;
28919
28920 if (!args) SWIG_fail;
28921 swig_obj[0] = args;
28922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28923 if (!SWIG_IsOK(res1)) {
28924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28925 }
28926 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 delete arg1;
28930
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_Py_Void();
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *obj;
28943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28944 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28945 return SWIG_Py_Void();
28946 }
28947
28948 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28949 return SWIG_Python_InitShadowInstance(args);
28950 }
28951
28952 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28953 PyObject *resultobj = 0;
28954 int arg1 = (int) 0 ;
28955 int arg2 = (int) 0 ;
28956 int arg3 = (int) 0 ;
28957 wxAcceleratorEntry *result = 0 ;
28958 int val1 ;
28959 int ecode1 = 0 ;
28960 int val2 ;
28961 int ecode2 = 0 ;
28962 int val3 ;
28963 int ecode3 = 0 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 PyObject * obj2 = 0 ;
28967 char * kwnames[] = {
28968 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28969 };
28970
28971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28972 if (obj0) {
28973 ecode1 = SWIG_AsVal_int(obj0, &val1);
28974 if (!SWIG_IsOK(ecode1)) {
28975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28976 }
28977 arg1 = static_cast< int >(val1);
28978 }
28979 if (obj1) {
28980 ecode2 = SWIG_AsVal_int(obj1, &val2);
28981 if (!SWIG_IsOK(ecode2)) {
28982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28983 }
28984 arg2 = static_cast< int >(val2);
28985 }
28986 if (obj2) {
28987 ecode3 = SWIG_AsVal_int(obj2, &val3);
28988 if (!SWIG_IsOK(ecode3)) {
28989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28990 }
28991 arg3 = static_cast< int >(val3);
28992 }
28993 {
28994 PyThreadState* __tstate = wxPyBeginAllowThreads();
28995 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29007 PyObject *resultobj = 0;
29008 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29009 void *argp1 = 0 ;
29010 int res1 = 0 ;
29011 PyObject *swig_obj[1] ;
29012
29013 if (!args) SWIG_fail;
29014 swig_obj[0] = args;
29015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29016 if (!SWIG_IsOK(res1)) {
29017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29018 }
29019 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 delete arg1;
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_Py_Void();
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29037 int arg2 ;
29038 int arg3 ;
29039 int arg4 ;
29040 void *argp1 = 0 ;
29041 int res1 = 0 ;
29042 int val2 ;
29043 int ecode2 = 0 ;
29044 int val3 ;
29045 int ecode3 = 0 ;
29046 int val4 ;
29047 int ecode4 = 0 ;
29048 PyObject * obj0 = 0 ;
29049 PyObject * obj1 = 0 ;
29050 PyObject * obj2 = 0 ;
29051 PyObject * obj3 = 0 ;
29052 char * kwnames[] = {
29053 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29054 };
29055
29056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29058 if (!SWIG_IsOK(res1)) {
29059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29060 }
29061 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29062 ecode2 = SWIG_AsVal_int(obj1, &val2);
29063 if (!SWIG_IsOK(ecode2)) {
29064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29065 }
29066 arg2 = static_cast< int >(val2);
29067 ecode3 = SWIG_AsVal_int(obj2, &val3);
29068 if (!SWIG_IsOK(ecode3)) {
29069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29070 }
29071 arg3 = static_cast< int >(val3);
29072 ecode4 = SWIG_AsVal_int(obj3, &val4);
29073 if (!SWIG_IsOK(ecode4)) {
29074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29075 }
29076 arg4 = static_cast< int >(val4);
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 (arg1)->Set(arg2,arg3,arg4);
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 resultobj = SWIG_Py_Void();
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29091 PyObject *resultobj = 0;
29092 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29093 int result;
29094 void *argp1 = 0 ;
29095 int res1 = 0 ;
29096 PyObject *swig_obj[1] ;
29097
29098 if (!args) SWIG_fail;
29099 swig_obj[0] = args;
29100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29101 if (!SWIG_IsOK(res1)) {
29102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29103 }
29104 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 result = (int)(arg1)->GetFlags();
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 resultobj = SWIG_From_int(static_cast< int >(result));
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 PyObject *resultobj = 0;
29120 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29121 int result;
29122 void *argp1 = 0 ;
29123 int res1 = 0 ;
29124 PyObject *swig_obj[1] ;
29125
29126 if (!args) SWIG_fail;
29127 swig_obj[0] = args;
29128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29129 if (!SWIG_IsOK(res1)) {
29130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29131 }
29132 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 result = (int)(arg1)->GetKeyCode();
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 resultobj = SWIG_From_int(static_cast< int >(result));
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29147 PyObject *resultobj = 0;
29148 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29149 int result;
29150 void *argp1 = 0 ;
29151 int res1 = 0 ;
29152 PyObject *swig_obj[1] ;
29153
29154 if (!args) SWIG_fail;
29155 swig_obj[0] = args;
29156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29157 if (!SWIG_IsOK(res1)) {
29158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29159 }
29160 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (int)(arg1)->GetCommand();
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 resultobj = SWIG_From_int(static_cast< int >(result));
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 PyObject *obj;
29176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29177 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29178 return SWIG_Py_Void();
29179 }
29180
29181 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29182 return SWIG_Python_InitShadowInstance(args);
29183 }
29184
29185 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29186 PyObject *resultobj = 0;
29187 int arg1 ;
29188 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29189 wxAcceleratorTable *result = 0 ;
29190 PyObject * obj0 = 0 ;
29191 char * kwnames[] = {
29192 (char *) "n", NULL
29193 };
29194
29195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29196 {
29197 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29198 if (arg2) arg1 = PyList_Size(obj0);
29199 else arg1 = 0;
29200 }
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *resultobj = 0;
29216 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29217 void *argp1 = 0 ;
29218 int res1 = 0 ;
29219 PyObject *swig_obj[1] ;
29220
29221 if (!args) SWIG_fail;
29222 swig_obj[0] = args;
29223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29224 if (!SWIG_IsOK(res1)) {
29225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29226 }
29227 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 delete arg1;
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_Py_Void();
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29245 bool result;
29246 void *argp1 = 0 ;
29247 int res1 = 0 ;
29248 PyObject *swig_obj[1] ;
29249
29250 if (!args) SWIG_fail;
29251 swig_obj[0] = args;
29252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29253 if (!SWIG_IsOK(res1)) {
29254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29255 }
29256 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 {
29264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29265 }
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29273 PyObject *obj;
29274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29275 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29276 return SWIG_Py_Void();
29277 }
29278
29279 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 return SWIG_Python_InitShadowInstance(args);
29281 }
29282
29283 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29284 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29285 return 1;
29286 }
29287
29288
29289 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29290 PyObject *pyobj = 0;
29291
29292 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29293 return pyobj;
29294 }
29295
29296
29297 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj = 0;
29299 wxString *arg1 = 0 ;
29300 wxAcceleratorEntry *result = 0 ;
29301 bool temp1 = false ;
29302 PyObject * obj0 = 0 ;
29303 char * kwnames[] = {
29304 (char *) "label", NULL
29305 };
29306
29307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29308 {
29309 arg1 = wxString_in_helper(obj0);
29310 if (arg1 == NULL) SWIG_fail;
29311 temp1 = true;
29312 }
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29316 wxPyEndAllowThreads(__tstate);
29317 if (PyErr_Occurred()) SWIG_fail;
29318 }
29319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29320 {
29321 if (temp1)
29322 delete arg1;
29323 }
29324 return resultobj;
29325 fail:
29326 {
29327 if (temp1)
29328 delete arg1;
29329 }
29330 return NULL;
29331 }
29332
29333
29334 SWIGINTERN int PanelNameStr_set(PyObject *) {
29335 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29336 return 1;
29337 }
29338
29339
29340 SWIGINTERN PyObject *PanelNameStr_get(void) {
29341 PyObject *pyobj = 0;
29342
29343 {
29344 #if wxUSE_UNICODE
29345 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29346 #else
29347 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29348 #endif
29349 }
29350 return pyobj;
29351 }
29352
29353
29354 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 PyObject *resultobj = 0;
29356 wxVisualAttributes *result = 0 ;
29357
29358 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29359 {
29360 PyThreadState* __tstate = wxPyBeginAllowThreads();
29361 result = (wxVisualAttributes *)new_wxVisualAttributes();
29362 wxPyEndAllowThreads(__tstate);
29363 if (PyErr_Occurred()) SWIG_fail;
29364 }
29365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29366 return resultobj;
29367 fail:
29368 return NULL;
29369 }
29370
29371
29372 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29373 PyObject *resultobj = 0;
29374 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29375 void *argp1 = 0 ;
29376 int res1 = 0 ;
29377 PyObject *swig_obj[1] ;
29378
29379 if (!args) SWIG_fail;
29380 swig_obj[0] = args;
29381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29382 if (!SWIG_IsOK(res1)) {
29383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29384 }
29385 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 delete_wxVisualAttributes(arg1);
29389
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_Py_Void();
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29403 wxFont *arg2 = (wxFont *) 0 ;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 void *argp2 = 0 ;
29407 int res2 = 0 ;
29408 PyObject *swig_obj[2] ;
29409
29410 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29412 if (!SWIG_IsOK(res1)) {
29413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29414 }
29415 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29416 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29417 if (!SWIG_IsOK(res2)) {
29418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29419 }
29420 arg2 = reinterpret_cast< wxFont * >(argp2);
29421 if (arg1) (arg1)->font = *arg2;
29422
29423 resultobj = SWIG_Py_Void();
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29431 PyObject *resultobj = 0;
29432 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29433 wxFont *result = 0 ;
29434 void *argp1 = 0 ;
29435 int res1 = 0 ;
29436 PyObject *swig_obj[1] ;
29437
29438 if (!args) SWIG_fail;
29439 swig_obj[0] = args;
29440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29441 if (!SWIG_IsOK(res1)) {
29442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29443 }
29444 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29445 result = (wxFont *)& ((arg1)->font);
29446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454 PyObject *resultobj = 0;
29455 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29456 wxColour *arg2 = (wxColour *) 0 ;
29457 void *argp1 = 0 ;
29458 int res1 = 0 ;
29459 void *argp2 = 0 ;
29460 int res2 = 0 ;
29461 PyObject *swig_obj[2] ;
29462
29463 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29465 if (!SWIG_IsOK(res1)) {
29466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29467 }
29468 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29470 if (!SWIG_IsOK(res2)) {
29471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29472 }
29473 arg2 = reinterpret_cast< wxColour * >(argp2);
29474 if (arg1) (arg1)->colFg = *arg2;
29475
29476 resultobj = SWIG_Py_Void();
29477 return resultobj;
29478 fail:
29479 return NULL;
29480 }
29481
29482
29483 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29484 PyObject *resultobj = 0;
29485 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29486 wxColour *result = 0 ;
29487 void *argp1 = 0 ;
29488 int res1 = 0 ;
29489 PyObject *swig_obj[1] ;
29490
29491 if (!args) SWIG_fail;
29492 swig_obj[0] = args;
29493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29494 if (!SWIG_IsOK(res1)) {
29495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29496 }
29497 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29498 result = (wxColour *)& ((arg1)->colFg);
29499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29500 return resultobj;
29501 fail:
29502 return NULL;
29503 }
29504
29505
29506 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29507 PyObject *resultobj = 0;
29508 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29509 wxColour *arg2 = (wxColour *) 0 ;
29510 void *argp1 = 0 ;
29511 int res1 = 0 ;
29512 void *argp2 = 0 ;
29513 int res2 = 0 ;
29514 PyObject *swig_obj[2] ;
29515
29516 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29518 if (!SWIG_IsOK(res1)) {
29519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29520 }
29521 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29522 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29523 if (!SWIG_IsOK(res2)) {
29524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29525 }
29526 arg2 = reinterpret_cast< wxColour * >(argp2);
29527 if (arg1) (arg1)->colBg = *arg2;
29528
29529 resultobj = SWIG_Py_Void();
29530 return resultobj;
29531 fail:
29532 return NULL;
29533 }
29534
29535
29536 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29537 PyObject *resultobj = 0;
29538 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29539 wxColour *result = 0 ;
29540 void *argp1 = 0 ;
29541 int res1 = 0 ;
29542 PyObject *swig_obj[1] ;
29543
29544 if (!args) SWIG_fail;
29545 swig_obj[0] = args;
29546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29547 if (!SWIG_IsOK(res1)) {
29548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29549 }
29550 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29551 result = (wxColour *)& ((arg1)->colBg);
29552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29560 PyObject *obj;
29561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29562 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29563 return SWIG_Py_Void();
29564 }
29565
29566 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29567 return SWIG_Python_InitShadowInstance(args);
29568 }
29569
29570 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29571 PyObject *resultobj = 0;
29572 wxWindow *arg1 = (wxWindow *) 0 ;
29573 int arg2 = (int) (int)-1 ;
29574 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29575 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29576 wxSize const &arg4_defvalue = wxDefaultSize ;
29577 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29578 long arg5 = (long) 0 ;
29579 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29580 wxString *arg6 = (wxString *) &arg6_defvalue ;
29581 wxWindow *result = 0 ;
29582 void *argp1 = 0 ;
29583 int res1 = 0 ;
29584 int val2 ;
29585 int ecode2 = 0 ;
29586 wxPoint temp3 ;
29587 wxSize temp4 ;
29588 long val5 ;
29589 int ecode5 = 0 ;
29590 bool temp6 = false ;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 PyObject * obj2 = 0 ;
29594 PyObject * obj3 = 0 ;
29595 PyObject * obj4 = 0 ;
29596 PyObject * obj5 = 0 ;
29597 char * kwnames[] = {
29598 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29599 };
29600
29601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29605 }
29606 arg1 = reinterpret_cast< wxWindow * >(argp1);
29607 if (obj1) {
29608 ecode2 = SWIG_AsVal_int(obj1, &val2);
29609 if (!SWIG_IsOK(ecode2)) {
29610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29611 }
29612 arg2 = static_cast< int >(val2);
29613 }
29614 if (obj2) {
29615 {
29616 arg3 = &temp3;
29617 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29618 }
29619 }
29620 if (obj3) {
29621 {
29622 arg4 = &temp4;
29623 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29624 }
29625 }
29626 if (obj4) {
29627 ecode5 = SWIG_AsVal_long(obj4, &val5);
29628 if (!SWIG_IsOK(ecode5)) {
29629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29630 }
29631 arg5 = static_cast< long >(val5);
29632 }
29633 if (obj5) {
29634 {
29635 arg6 = wxString_in_helper(obj5);
29636 if (arg6 == NULL) SWIG_fail;
29637 temp6 = true;
29638 }
29639 }
29640 {
29641 if (!wxPyCheckForApp()) SWIG_fail;
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29648 {
29649 if (temp6)
29650 delete arg6;
29651 }
29652 return resultobj;
29653 fail:
29654 {
29655 if (temp6)
29656 delete arg6;
29657 }
29658 return NULL;
29659 }
29660
29661
29662 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29663 PyObject *resultobj = 0;
29664 wxWindow *result = 0 ;
29665
29666 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29667 {
29668 if (!wxPyCheckForApp()) SWIG_fail;
29669 PyThreadState* __tstate = wxPyBeginAllowThreads();
29670 result = (wxWindow *)new wxWindow();
29671 wxPyEndAllowThreads(__tstate);
29672 if (PyErr_Occurred()) SWIG_fail;
29673 }
29674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 wxWindow *arg2 = (wxWindow *) 0 ;
29685 int arg3 = (int) (int)-1 ;
29686 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29687 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29688 wxSize const &arg5_defvalue = wxDefaultSize ;
29689 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29690 long arg6 = (long) 0 ;
29691 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29692 wxString *arg7 = (wxString *) &arg7_defvalue ;
29693 bool result;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 void *argp2 = 0 ;
29697 int res2 = 0 ;
29698 int val3 ;
29699 int ecode3 = 0 ;
29700 wxPoint temp4 ;
29701 wxSize temp5 ;
29702 long val6 ;
29703 int ecode6 = 0 ;
29704 bool temp7 = false ;
29705 PyObject * obj0 = 0 ;
29706 PyObject * obj1 = 0 ;
29707 PyObject * obj2 = 0 ;
29708 PyObject * obj3 = 0 ;
29709 PyObject * obj4 = 0 ;
29710 PyObject * obj5 = 0 ;
29711 PyObject * obj6 = 0 ;
29712 char * kwnames[] = {
29713 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29714 };
29715
29716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29718 if (!SWIG_IsOK(res1)) {
29719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29720 }
29721 arg1 = reinterpret_cast< wxWindow * >(argp1);
29722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29723 if (!SWIG_IsOK(res2)) {
29724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29725 }
29726 arg2 = reinterpret_cast< wxWindow * >(argp2);
29727 if (obj2) {
29728 ecode3 = SWIG_AsVal_int(obj2, &val3);
29729 if (!SWIG_IsOK(ecode3)) {
29730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29731 }
29732 arg3 = static_cast< int >(val3);
29733 }
29734 if (obj3) {
29735 {
29736 arg4 = &temp4;
29737 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29738 }
29739 }
29740 if (obj4) {
29741 {
29742 arg5 = &temp5;
29743 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29744 }
29745 }
29746 if (obj5) {
29747 ecode6 = SWIG_AsVal_long(obj5, &val6);
29748 if (!SWIG_IsOK(ecode6)) {
29749 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29750 }
29751 arg6 = static_cast< long >(val6);
29752 }
29753 if (obj6) {
29754 {
29755 arg7 = wxString_in_helper(obj6);
29756 if (arg7 == NULL) SWIG_fail;
29757 temp7 = true;
29758 }
29759 }
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 {
29767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29768 }
29769 {
29770 if (temp7)
29771 delete arg7;
29772 }
29773 return resultobj;
29774 fail:
29775 {
29776 if (temp7)
29777 delete arg7;
29778 }
29779 return NULL;
29780 }
29781
29782
29783 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29784 PyObject *resultobj = 0;
29785 wxWindow *arg1 = (wxWindow *) 0 ;
29786 bool arg2 = (bool) false ;
29787 bool result;
29788 void *argp1 = 0 ;
29789 int res1 = 0 ;
29790 bool val2 ;
29791 int ecode2 = 0 ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 char * kwnames[] = {
29795 (char *) "self",(char *) "force", NULL
29796 };
29797
29798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29802 }
29803 arg1 = reinterpret_cast< wxWindow * >(argp1);
29804 if (obj1) {
29805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29806 if (!SWIG_IsOK(ecode2)) {
29807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29808 }
29809 arg2 = static_cast< bool >(val2);
29810 }
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 result = (bool)(arg1)->Close(arg2);
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 {
29818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29819 }
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29827 PyObject *resultobj = 0;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 bool result;
29830 void *argp1 = 0 ;
29831 int res1 = 0 ;
29832 PyObject *swig_obj[1] ;
29833
29834 if (!args) SWIG_fail;
29835 swig_obj[0] = args;
29836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29837 if (!SWIG_IsOK(res1)) {
29838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29839 }
29840 arg1 = reinterpret_cast< wxWindow * >(argp1);
29841 {
29842 PyThreadState* __tstate = wxPyBeginAllowThreads();
29843 result = (bool)(arg1)->Destroy();
29844 wxPyEndAllowThreads(__tstate);
29845 if (PyErr_Occurred()) SWIG_fail;
29846 }
29847 {
29848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29849 }
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29857 PyObject *resultobj = 0;
29858 wxWindow *arg1 = (wxWindow *) 0 ;
29859 bool result;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 PyObject *swig_obj[1] ;
29863
29864 if (!args) SWIG_fail;
29865 swig_obj[0] = args;
29866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29867 if (!SWIG_IsOK(res1)) {
29868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29869 }
29870 arg1 = reinterpret_cast< wxWindow * >(argp1);
29871 {
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (bool)(arg1)->DestroyChildren();
29874 wxPyEndAllowThreads(__tstate);
29875 if (PyErr_Occurred()) SWIG_fail;
29876 }
29877 {
29878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29879 }
29880 return resultobj;
29881 fail:
29882 return NULL;
29883 }
29884
29885
29886 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29887 PyObject *resultobj = 0;
29888 wxWindow *arg1 = (wxWindow *) 0 ;
29889 bool result;
29890 void *argp1 = 0 ;
29891 int res1 = 0 ;
29892 PyObject *swig_obj[1] ;
29893
29894 if (!args) SWIG_fail;
29895 swig_obj[0] = args;
29896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29897 if (!SWIG_IsOK(res1)) {
29898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29899 }
29900 arg1 = reinterpret_cast< wxWindow * >(argp1);
29901 {
29902 PyThreadState* __tstate = wxPyBeginAllowThreads();
29903 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29904 wxPyEndAllowThreads(__tstate);
29905 if (PyErr_Occurred()) SWIG_fail;
29906 }
29907 {
29908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29909 }
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj = 0;
29918 wxWindow *arg1 = (wxWindow *) 0 ;
29919 wxString *arg2 = 0 ;
29920 void *argp1 = 0 ;
29921 int res1 = 0 ;
29922 bool temp2 = false ;
29923 PyObject * obj0 = 0 ;
29924 PyObject * obj1 = 0 ;
29925 char * kwnames[] = {
29926 (char *) "self",(char *) "label", NULL
29927 };
29928
29929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29931 if (!SWIG_IsOK(res1)) {
29932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29933 }
29934 arg1 = reinterpret_cast< wxWindow * >(argp1);
29935 {
29936 arg2 = wxString_in_helper(obj1);
29937 if (arg2 == NULL) SWIG_fail;
29938 temp2 = true;
29939 }
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 (arg1)->SetLabel((wxString const &)*arg2);
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_Py_Void();
29947 {
29948 if (temp2)
29949 delete arg2;
29950 }
29951 return resultobj;
29952 fail:
29953 {
29954 if (temp2)
29955 delete arg2;
29956 }
29957 return NULL;
29958 }
29959
29960
29961 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29962 PyObject *resultobj = 0;
29963 wxWindow *arg1 = (wxWindow *) 0 ;
29964 wxString result;
29965 void *argp1 = 0 ;
29966 int res1 = 0 ;
29967 PyObject *swig_obj[1] ;
29968
29969 if (!args) SWIG_fail;
29970 swig_obj[0] = args;
29971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29972 if (!SWIG_IsOK(res1)) {
29973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29974 }
29975 arg1 = reinterpret_cast< wxWindow * >(argp1);
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 result = ((wxWindow const *)arg1)->GetLabel();
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 {
29983 #if wxUSE_UNICODE
29984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29985 #else
29986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29987 #endif
29988 }
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29996 PyObject *resultobj = 0;
29997 wxWindow *arg1 = (wxWindow *) 0 ;
29998 wxString *arg2 = 0 ;
29999 void *argp1 = 0 ;
30000 int res1 = 0 ;
30001 bool temp2 = false ;
30002 PyObject * obj0 = 0 ;
30003 PyObject * obj1 = 0 ;
30004 char * kwnames[] = {
30005 (char *) "self",(char *) "name", NULL
30006 };
30007
30008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30010 if (!SWIG_IsOK(res1)) {
30011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30012 }
30013 arg1 = reinterpret_cast< wxWindow * >(argp1);
30014 {
30015 arg2 = wxString_in_helper(obj1);
30016 if (arg2 == NULL) SWIG_fail;
30017 temp2 = true;
30018 }
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 (arg1)->SetName((wxString const &)*arg2);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_Py_Void();
30026 {
30027 if (temp2)
30028 delete arg2;
30029 }
30030 return resultobj;
30031 fail:
30032 {
30033 if (temp2)
30034 delete arg2;
30035 }
30036 return NULL;
30037 }
30038
30039
30040 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30041 PyObject *resultobj = 0;
30042 wxWindow *arg1 = (wxWindow *) 0 ;
30043 wxString result;
30044 void *argp1 = 0 ;
30045 int res1 = 0 ;
30046 PyObject *swig_obj[1] ;
30047
30048 if (!args) SWIG_fail;
30049 swig_obj[0] = args;
30050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30051 if (!SWIG_IsOK(res1)) {
30052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30053 }
30054 arg1 = reinterpret_cast< wxWindow * >(argp1);
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = ((wxWindow const *)arg1)->GetName();
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 #if wxUSE_UNICODE
30063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30064 #else
30065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30066 #endif
30067 }
30068 return resultobj;
30069 fail:
30070 return NULL;
30071 }
30072
30073
30074 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30075 PyObject *resultobj = 0;
30076 wxWindow *arg1 = (wxWindow *) 0 ;
30077 wxWindowVariant arg2 ;
30078 void *argp1 = 0 ;
30079 int res1 = 0 ;
30080 int val2 ;
30081 int ecode2 = 0 ;
30082 PyObject * obj0 = 0 ;
30083 PyObject * obj1 = 0 ;
30084 char * kwnames[] = {
30085 (char *) "self",(char *) "variant", NULL
30086 };
30087
30088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30092 }
30093 arg1 = reinterpret_cast< wxWindow * >(argp1);
30094 ecode2 = SWIG_AsVal_int(obj1, &val2);
30095 if (!SWIG_IsOK(ecode2)) {
30096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30097 }
30098 arg2 = static_cast< wxWindowVariant >(val2);
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 (arg1)->SetWindowVariant(arg2);
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 resultobj = SWIG_Py_Void();
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30113 PyObject *resultobj = 0;
30114 wxWindow *arg1 = (wxWindow *) 0 ;
30115 wxWindowVariant result;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 PyObject *swig_obj[1] ;
30119
30120 if (!args) SWIG_fail;
30121 swig_obj[0] = args;
30122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30123 if (!SWIG_IsOK(res1)) {
30124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30125 }
30126 arg1 = reinterpret_cast< wxWindow * >(argp1);
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_From_int(static_cast< int >(result));
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30141 PyObject *resultobj = 0;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 int arg2 ;
30144 void *argp1 = 0 ;
30145 int res1 = 0 ;
30146 int val2 ;
30147 int ecode2 = 0 ;
30148 PyObject * obj0 = 0 ;
30149 PyObject * obj1 = 0 ;
30150 char * kwnames[] = {
30151 (char *) "self",(char *) "winid", NULL
30152 };
30153
30154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30156 if (!SWIG_IsOK(res1)) {
30157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30158 }
30159 arg1 = reinterpret_cast< wxWindow * >(argp1);
30160 ecode2 = SWIG_AsVal_int(obj1, &val2);
30161 if (!SWIG_IsOK(ecode2)) {
30162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30163 }
30164 arg2 = static_cast< int >(val2);
30165 {
30166 PyThreadState* __tstate = wxPyBeginAllowThreads();
30167 (arg1)->SetId(arg2);
30168 wxPyEndAllowThreads(__tstate);
30169 if (PyErr_Occurred()) SWIG_fail;
30170 }
30171 resultobj = SWIG_Py_Void();
30172 return resultobj;
30173 fail:
30174 return NULL;
30175 }
30176
30177
30178 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30179 PyObject *resultobj = 0;
30180 wxWindow *arg1 = (wxWindow *) 0 ;
30181 int result;
30182 void *argp1 = 0 ;
30183 int res1 = 0 ;
30184 PyObject *swig_obj[1] ;
30185
30186 if (!args) SWIG_fail;
30187 swig_obj[0] = args;
30188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30189 if (!SWIG_IsOK(res1)) {
30190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30191 }
30192 arg1 = reinterpret_cast< wxWindow * >(argp1);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (int)((wxWindow const *)arg1)->GetId();
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_From_int(static_cast< int >(result));
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30207 PyObject *resultobj = 0;
30208 int result;
30209
30210 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 result = (int)wxWindow::NewControlId();
30214 wxPyEndAllowThreads(__tstate);
30215 if (PyErr_Occurred()) SWIG_fail;
30216 }
30217 resultobj = SWIG_From_int(static_cast< int >(result));
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj = 0;
30226 int arg1 ;
30227 int result;
30228 int val1 ;
30229 int ecode1 = 0 ;
30230 PyObject * obj0 = 0 ;
30231 char * kwnames[] = {
30232 (char *) "winid", NULL
30233 };
30234
30235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30236 ecode1 = SWIG_AsVal_int(obj0, &val1);
30237 if (!SWIG_IsOK(ecode1)) {
30238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30239 }
30240 arg1 = static_cast< int >(val1);
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (int)wxWindow::NextControlId(arg1);
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 resultobj = SWIG_From_int(static_cast< int >(result));
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30255 PyObject *resultobj = 0;
30256 int arg1 ;
30257 int result;
30258 int val1 ;
30259 int ecode1 = 0 ;
30260 PyObject * obj0 = 0 ;
30261 char * kwnames[] = {
30262 (char *) "winid", NULL
30263 };
30264
30265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30266 ecode1 = SWIG_AsVal_int(obj0, &val1);
30267 if (!SWIG_IsOK(ecode1)) {
30268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30269 }
30270 arg1 = static_cast< int >(val1);
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 result = (int)wxWindow::PrevControlId(arg1);
30274 wxPyEndAllowThreads(__tstate);
30275 if (PyErr_Occurred()) SWIG_fail;
30276 }
30277 resultobj = SWIG_From_int(static_cast< int >(result));
30278 return resultobj;
30279 fail:
30280 return NULL;
30281 }
30282
30283
30284 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30285 PyObject *resultobj = 0;
30286 wxWindow *arg1 = (wxWindow *) 0 ;
30287 wxSize *arg2 = 0 ;
30288 void *argp1 = 0 ;
30289 int res1 = 0 ;
30290 wxSize temp2 ;
30291 PyObject * obj0 = 0 ;
30292 PyObject * obj1 = 0 ;
30293 char * kwnames[] = {
30294 (char *) "self",(char *) "size", NULL
30295 };
30296
30297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30299 if (!SWIG_IsOK(res1)) {
30300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30301 }
30302 arg1 = reinterpret_cast< wxWindow * >(argp1);
30303 {
30304 arg2 = &temp2;
30305 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 (arg1)->SetSize((wxSize const &)*arg2);
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_Py_Void();
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = 0;
30322 wxWindow *arg1 = (wxWindow *) 0 ;
30323 int arg2 ;
30324 int arg3 ;
30325 int arg4 ;
30326 int arg5 ;
30327 int arg6 = (int) wxSIZE_AUTO ;
30328 void *argp1 = 0 ;
30329 int res1 = 0 ;
30330 int val2 ;
30331 int ecode2 = 0 ;
30332 int val3 ;
30333 int ecode3 = 0 ;
30334 int val4 ;
30335 int ecode4 = 0 ;
30336 int val5 ;
30337 int ecode5 = 0 ;
30338 int val6 ;
30339 int ecode6 = 0 ;
30340 PyObject * obj0 = 0 ;
30341 PyObject * obj1 = 0 ;
30342 PyObject * obj2 = 0 ;
30343 PyObject * obj3 = 0 ;
30344 PyObject * obj4 = 0 ;
30345 PyObject * obj5 = 0 ;
30346 char * kwnames[] = {
30347 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30348 };
30349
30350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30352 if (!SWIG_IsOK(res1)) {
30353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30354 }
30355 arg1 = reinterpret_cast< wxWindow * >(argp1);
30356 ecode2 = SWIG_AsVal_int(obj1, &val2);
30357 if (!SWIG_IsOK(ecode2)) {
30358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30359 }
30360 arg2 = static_cast< int >(val2);
30361 ecode3 = SWIG_AsVal_int(obj2, &val3);
30362 if (!SWIG_IsOK(ecode3)) {
30363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30364 }
30365 arg3 = static_cast< int >(val3);
30366 ecode4 = SWIG_AsVal_int(obj3, &val4);
30367 if (!SWIG_IsOK(ecode4)) {
30368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30369 }
30370 arg4 = static_cast< int >(val4);
30371 ecode5 = SWIG_AsVal_int(obj4, &val5);
30372 if (!SWIG_IsOK(ecode5)) {
30373 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30374 }
30375 arg5 = static_cast< int >(val5);
30376 if (obj5) {
30377 ecode6 = SWIG_AsVal_int(obj5, &val6);
30378 if (!SWIG_IsOK(ecode6)) {
30379 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30380 }
30381 arg6 = static_cast< int >(val6);
30382 }
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_Py_Void();
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = 0;
30398 wxWindow *arg1 = (wxWindow *) 0 ;
30399 wxRect *arg2 = 0 ;
30400 int arg3 = (int) wxSIZE_AUTO ;
30401 void *argp1 = 0 ;
30402 int res1 = 0 ;
30403 wxRect temp2 ;
30404 int val3 ;
30405 int ecode3 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 {
30420 arg2 = &temp2;
30421 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30422 }
30423 if (obj2) {
30424 ecode3 = SWIG_AsVal_int(obj2, &val3);
30425 if (!SWIG_IsOK(ecode3)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30427 }
30428 arg3 = static_cast< int >(val3);
30429 }
30430 {
30431 PyThreadState* __tstate = wxPyBeginAllowThreads();
30432 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30433 wxPyEndAllowThreads(__tstate);
30434 if (PyErr_Occurred()) SWIG_fail;
30435 }
30436 resultobj = SWIG_Py_Void();
30437 return resultobj;
30438 fail:
30439 return NULL;
30440 }
30441
30442
30443 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30444 PyObject *resultobj = 0;
30445 wxWindow *arg1 = (wxWindow *) 0 ;
30446 int arg2 ;
30447 int arg3 ;
30448 void *argp1 = 0 ;
30449 int res1 = 0 ;
30450 int val2 ;
30451 int ecode2 = 0 ;
30452 int val3 ;
30453 int ecode3 = 0 ;
30454 PyObject * obj0 = 0 ;
30455 PyObject * obj1 = 0 ;
30456 PyObject * obj2 = 0 ;
30457 char * kwnames[] = {
30458 (char *) "self",(char *) "width",(char *) "height", NULL
30459 };
30460
30461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30463 if (!SWIG_IsOK(res1)) {
30464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30465 }
30466 arg1 = reinterpret_cast< wxWindow * >(argp1);
30467 ecode2 = SWIG_AsVal_int(obj1, &val2);
30468 if (!SWIG_IsOK(ecode2)) {
30469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30470 }
30471 arg2 = static_cast< int >(val2);
30472 ecode3 = SWIG_AsVal_int(obj2, &val3);
30473 if (!SWIG_IsOK(ecode3)) {
30474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30475 }
30476 arg3 = static_cast< int >(val3);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 (arg1)->SetSize(arg2,arg3);
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 resultobj = SWIG_Py_Void();
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj = 0;
30492 wxWindow *arg1 = (wxWindow *) 0 ;
30493 wxPoint *arg2 = 0 ;
30494 int arg3 = (int) wxSIZE_USE_EXISTING ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 wxPoint temp2 ;
30498 int val3 ;
30499 int ecode3 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 PyObject * obj2 = 0 ;
30503 char * kwnames[] = {
30504 (char *) "self",(char *) "pt",(char *) "flags", NULL
30505 };
30506
30507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30509 if (!SWIG_IsOK(res1)) {
30510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30511 }
30512 arg1 = reinterpret_cast< wxWindow * >(argp1);
30513 {
30514 arg2 = &temp2;
30515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30516 }
30517 if (obj2) {
30518 ecode3 = SWIG_AsVal_int(obj2, &val3);
30519 if (!SWIG_IsOK(ecode3)) {
30520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30521 }
30522 arg3 = static_cast< int >(val3);
30523 }
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 (arg1)->Move((wxPoint const &)*arg2,arg3);
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 resultobj = SWIG_Py_Void();
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30538 PyObject *resultobj = 0;
30539 wxWindow *arg1 = (wxWindow *) 0 ;
30540 int arg2 ;
30541 int arg3 ;
30542 int arg4 = (int) wxSIZE_USE_EXISTING ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 int val2 ;
30546 int ecode2 = 0 ;
30547 int val3 ;
30548 int ecode3 = 0 ;
30549 int val4 ;
30550 int ecode4 = 0 ;
30551 PyObject * obj0 = 0 ;
30552 PyObject * obj1 = 0 ;
30553 PyObject * obj2 = 0 ;
30554 PyObject * obj3 = 0 ;
30555 char * kwnames[] = {
30556 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30557 };
30558
30559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30561 if (!SWIG_IsOK(res1)) {
30562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30563 }
30564 arg1 = reinterpret_cast< wxWindow * >(argp1);
30565 ecode2 = SWIG_AsVal_int(obj1, &val2);
30566 if (!SWIG_IsOK(ecode2)) {
30567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30568 }
30569 arg2 = static_cast< int >(val2);
30570 ecode3 = SWIG_AsVal_int(obj2, &val3);
30571 if (!SWIG_IsOK(ecode3)) {
30572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30573 }
30574 arg3 = static_cast< int >(val3);
30575 if (obj3) {
30576 ecode4 = SWIG_AsVal_int(obj3, &val4);
30577 if (!SWIG_IsOK(ecode4)) {
30578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30579 }
30580 arg4 = static_cast< int >(val4);
30581 }
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 (arg1)->Move(arg2,arg3,arg4);
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 resultobj = SWIG_Py_Void();
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30596 PyObject *resultobj = 0;
30597 wxWindow *arg1 = (wxWindow *) 0 ;
30598 wxSize const &arg2_defvalue = wxDefaultSize ;
30599 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30600 void *argp1 = 0 ;
30601 int res1 = 0 ;
30602 wxSize temp2 ;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "self",(char *) "size", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 if (obj1) {
30616 {
30617 arg2 = &temp2;
30618 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30619 }
30620 }
30621 {
30622 PyThreadState* __tstate = wxPyBeginAllowThreads();
30623 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30624 wxPyEndAllowThreads(__tstate);
30625 if (PyErr_Occurred()) SWIG_fail;
30626 }
30627 resultobj = SWIG_Py_Void();
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30635 PyObject *resultobj = 0;
30636 wxWindow *arg1 = (wxWindow *) 0 ;
30637 void *argp1 = 0 ;
30638 int res1 = 0 ;
30639 PyObject *swig_obj[1] ;
30640
30641 if (!args) SWIG_fail;
30642 swig_obj[0] = args;
30643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30644 if (!SWIG_IsOK(res1)) {
30645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30646 }
30647 arg1 = reinterpret_cast< wxWindow * >(argp1);
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 (arg1)->Raise();
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 resultobj = SWIG_Py_Void();
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30673 }
30674 arg1 = reinterpret_cast< wxWindow * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 (arg1)->Lower();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_Py_Void();
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj = 0;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 wxSize *arg2 = 0 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 wxSize temp2 ;
30695 PyObject * obj0 = 0 ;
30696 PyObject * obj1 = 0 ;
30697 char * kwnames[] = {
30698 (char *) "self",(char *) "size", NULL
30699 };
30700
30701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30703 if (!SWIG_IsOK(res1)) {
30704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30705 }
30706 arg1 = reinterpret_cast< wxWindow * >(argp1);
30707 {
30708 arg2 = &temp2;
30709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 (arg1)->SetClientSize((wxSize const &)*arg2);
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_Py_Void();
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30725 PyObject *resultobj = 0;
30726 wxWindow *arg1 = (wxWindow *) 0 ;
30727 int arg2 ;
30728 int arg3 ;
30729 void *argp1 = 0 ;
30730 int res1 = 0 ;
30731 int val2 ;
30732 int ecode2 = 0 ;
30733 int val3 ;
30734 int ecode3 = 0 ;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 PyObject * obj2 = 0 ;
30738 char * kwnames[] = {
30739 (char *) "self",(char *) "width",(char *) "height", NULL
30740 };
30741
30742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30744 if (!SWIG_IsOK(res1)) {
30745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30746 }
30747 arg1 = reinterpret_cast< wxWindow * >(argp1);
30748 ecode2 = SWIG_AsVal_int(obj1, &val2);
30749 if (!SWIG_IsOK(ecode2)) {
30750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30751 }
30752 arg2 = static_cast< int >(val2);
30753 ecode3 = SWIG_AsVal_int(obj2, &val3);
30754 if (!SWIG_IsOK(ecode3)) {
30755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30756 }
30757 arg3 = static_cast< int >(val3);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 (arg1)->SetClientSize(arg2,arg3);
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_Py_Void();
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj = 0;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxRect *arg2 = 0 ;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 wxRect temp2 ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 char * kwnames[] = {
30781 (char *) "self",(char *) "rect", NULL
30782 };
30783
30784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30786 if (!SWIG_IsOK(res1)) {
30787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30788 }
30789 arg1 = reinterpret_cast< wxWindow * >(argp1);
30790 {
30791 arg2 = &temp2;
30792 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30793 }
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 (arg1)->SetClientSize((wxRect const &)*arg2);
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 resultobj = SWIG_Py_Void();
30801 return resultobj;
30802 fail:
30803 return NULL;
30804 }
30805
30806
30807 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30808 PyObject *resultobj = 0;
30809 wxWindow *arg1 = (wxWindow *) 0 ;
30810 wxPoint result;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 PyObject *swig_obj[1] ;
30814
30815 if (!args) SWIG_fail;
30816 swig_obj[0] = args;
30817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30818 if (!SWIG_IsOK(res1)) {
30819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30820 }
30821 arg1 = reinterpret_cast< wxWindow * >(argp1);
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 result = ((wxWindow const *)arg1)->GetPosition();
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836 PyObject *resultobj = 0;
30837 wxWindow *arg1 = (wxWindow *) 0 ;
30838 int *arg2 = (int *) 0 ;
30839 int *arg3 = (int *) 0 ;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 int temp2 ;
30843 int res2 = SWIG_TMPOBJ ;
30844 int temp3 ;
30845 int res3 = SWIG_TMPOBJ ;
30846 PyObject *swig_obj[1] ;
30847
30848 arg2 = &temp2;
30849 arg3 = &temp3;
30850 if (!args) SWIG_fail;
30851 swig_obj[0] = args;
30852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30853 if (!SWIG_IsOK(res1)) {
30854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30855 }
30856 arg1 = reinterpret_cast< wxWindow * >(argp1);
30857 {
30858 PyThreadState* __tstate = wxPyBeginAllowThreads();
30859 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 resultobj = SWIG_Py_Void();
30864 if (SWIG_IsTmpObj(res2)) {
30865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30866 } else {
30867 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30869 }
30870 if (SWIG_IsTmpObj(res3)) {
30871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30872 } else {
30873 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30875 }
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30883 PyObject *resultobj = 0;
30884 wxWindow *arg1 = (wxWindow *) 0 ;
30885 wxPoint result;
30886 void *argp1 = 0 ;
30887 int res1 = 0 ;
30888 PyObject *swig_obj[1] ;
30889
30890 if (!args) SWIG_fail;
30891 swig_obj[0] = args;
30892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30893 if (!SWIG_IsOK(res1)) {
30894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30895 }
30896 arg1 = reinterpret_cast< wxWindow * >(argp1);
30897 {
30898 PyThreadState* __tstate = wxPyBeginAllowThreads();
30899 result = ((wxWindow const *)arg1)->GetScreenPosition();
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 int *arg2 = (int *) 0 ;
30914 int *arg3 = (int *) 0 ;
30915 void *argp1 = 0 ;
30916 int res1 = 0 ;
30917 int temp2 ;
30918 int res2 = SWIG_TMPOBJ ;
30919 int temp3 ;
30920 int res3 = SWIG_TMPOBJ ;
30921 PyObject *swig_obj[1] ;
30922
30923 arg2 = &temp2;
30924 arg3 = &temp3;
30925 if (!args) SWIG_fail;
30926 swig_obj[0] = args;
30927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30928 if (!SWIG_IsOK(res1)) {
30929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30930 }
30931 arg1 = reinterpret_cast< wxWindow * >(argp1);
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30935 wxPyEndAllowThreads(__tstate);
30936 if (PyErr_Occurred()) SWIG_fail;
30937 }
30938 resultobj = SWIG_Py_Void();
30939 if (SWIG_IsTmpObj(res2)) {
30940 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30941 } else {
30942 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30943 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30944 }
30945 if (SWIG_IsTmpObj(res3)) {
30946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30947 } else {
30948 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30950 }
30951 return resultobj;
30952 fail:
30953 return NULL;
30954 }
30955
30956
30957 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30958 PyObject *resultobj = 0;
30959 wxWindow *arg1 = (wxWindow *) 0 ;
30960 wxRect result;
30961 void *argp1 = 0 ;
30962 int res1 = 0 ;
30963 PyObject *swig_obj[1] ;
30964
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 result = ((wxWindow const *)arg1)->GetScreenRect();
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxSize result;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 PyObject *swig_obj[1] ;
30992
30993 if (!args) SWIG_fail;
30994 swig_obj[0] = args;
30995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetSize();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 int *arg2 = (int *) 0 ;
31017 int *arg3 = (int *) 0 ;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 int temp2 ;
31021 int res2 = SWIG_TMPOBJ ;
31022 int temp3 ;
31023 int res3 = SWIG_TMPOBJ ;
31024 PyObject *swig_obj[1] ;
31025
31026 arg2 = &temp2;
31027 arg3 = &temp3;
31028 if (!args) SWIG_fail;
31029 swig_obj[0] = args;
31030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31033 }
31034 arg1 = reinterpret_cast< wxWindow * >(argp1);
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 resultobj = SWIG_Py_Void();
31042 if (SWIG_IsTmpObj(res2)) {
31043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31044 } else {
31045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31047 }
31048 if (SWIG_IsTmpObj(res3)) {
31049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31050 } else {
31051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31053 }
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 wxRect result;
31064 void *argp1 = 0 ;
31065 int res1 = 0 ;
31066 PyObject *swig_obj[1] ;
31067
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31073 }
31074 arg1 = reinterpret_cast< wxWindow * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = ((wxWindow const *)arg1)->GetRect();
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxSize result;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 PyObject *swig_obj[1] ;
31095
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxWindow const *)arg1)->GetClientSize();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 int *arg2 = (int *) 0 ;
31120 int *arg3 = (int *) 0 ;
31121 void *argp1 = 0 ;
31122 int res1 = 0 ;
31123 int temp2 ;
31124 int res2 = SWIG_TMPOBJ ;
31125 int temp3 ;
31126 int res3 = SWIG_TMPOBJ ;
31127 PyObject *swig_obj[1] ;
31128
31129 arg2 = &temp2;
31130 arg3 = &temp3;
31131 if (!args) SWIG_fail;
31132 swig_obj[0] = args;
31133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31134 if (!SWIG_IsOK(res1)) {
31135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31136 }
31137 arg1 = reinterpret_cast< wxWindow * >(argp1);
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 resultobj = SWIG_Py_Void();
31145 if (SWIG_IsTmpObj(res2)) {
31146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31147 } else {
31148 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31150 }
31151 if (SWIG_IsTmpObj(res3)) {
31152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31153 } else {
31154 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31164 PyObject *resultobj = 0;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 wxPoint result;
31167 void *argp1 = 0 ;
31168 int res1 = 0 ;
31169 PyObject *swig_obj[1] ;
31170
31171 if (!args) SWIG_fail;
31172 swig_obj[0] = args;
31173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31174 if (!SWIG_IsOK(res1)) {
31175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31176 }
31177 arg1 = reinterpret_cast< wxWindow * >(argp1);
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31181 wxPyEndAllowThreads(__tstate);
31182 if (PyErr_Occurred()) SWIG_fail;
31183 }
31184 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 wxRect result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 PyObject *swig_obj[1] ;
31198
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = ((wxWindow const *)arg1)->GetClientRect();
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31220 PyObject *resultobj = 0;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxSize result;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = ((wxWindow const *)arg1)->GetBestSize();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 int *arg2 = (int *) 0 ;
31251 int *arg3 = (int *) 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 int temp2 ;
31255 int res2 = SWIG_TMPOBJ ;
31256 int temp3 ;
31257 int res3 = SWIG_TMPOBJ ;
31258 PyObject *swig_obj[1] ;
31259
31260 arg2 = &temp2;
31261 arg3 = &temp3;
31262 if (!args) SWIG_fail;
31263 swig_obj[0] = args;
31264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31265 if (!SWIG_IsOK(res1)) {
31266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31267 }
31268 arg1 = reinterpret_cast< wxWindow * >(argp1);
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_Py_Void();
31276 if (SWIG_IsTmpObj(res2)) {
31277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31278 } else {
31279 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31281 }
31282 if (SWIG_IsTmpObj(res3)) {
31283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31284 } else {
31285 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31287 }
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31295 PyObject *resultobj = 0;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 PyObject *swig_obj[1] ;
31300
31301 if (!args) SWIG_fail;
31302 swig_obj[0] = args;
31303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31304 if (!SWIG_IsOK(res1)) {
31305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31306 }
31307 arg1 = reinterpret_cast< wxWindow * >(argp1);
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 (arg1)->InvalidateBestSize();
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 resultobj = SWIG_Py_Void();
31315 return resultobj;
31316 fail:
31317 return NULL;
31318 }
31319
31320
31321 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31322 PyObject *resultobj = 0;
31323 wxWindow *arg1 = (wxWindow *) 0 ;
31324 wxSize *arg2 = 0 ;
31325 void *argp1 = 0 ;
31326 int res1 = 0 ;
31327 wxSize temp2 ;
31328 PyObject * obj0 = 0 ;
31329 PyObject * obj1 = 0 ;
31330 char * kwnames[] = {
31331 (char *) "self",(char *) "size", NULL
31332 };
31333
31334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31336 if (!SWIG_IsOK(res1)) {
31337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31338 }
31339 arg1 = reinterpret_cast< wxWindow * >(argp1);
31340 {
31341 arg2 = &temp2;
31342 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31343 }
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31347 wxPyEndAllowThreads(__tstate);
31348 if (PyErr_Occurred()) SWIG_fail;
31349 }
31350 resultobj = SWIG_Py_Void();
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 wxWindow *arg1 = (wxWindow *) 0 ;
31360 wxSize result;
31361 void *argp1 = 0 ;
31362 int res1 = 0 ;
31363 PyObject *swig_obj[1] ;
31364
31365 if (!args) SWIG_fail;
31366 swig_obj[0] = args;
31367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31368 if (!SWIG_IsOK(res1)) {
31369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31370 }
31371 arg1 = reinterpret_cast< wxWindow * >(argp1);
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 wxSize result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31398 }
31399 arg1 = reinterpret_cast< wxWindow * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 int arg2 = (int) wxBOTH ;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 int val2 ;
31420 int ecode2 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "self",(char *) "direction", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31429 if (!SWIG_IsOK(res1)) {
31430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31431 }
31432 arg1 = reinterpret_cast< wxWindow * >(argp1);
31433 if (obj1) {
31434 ecode2 = SWIG_AsVal_int(obj1, &val2);
31435 if (!SWIG_IsOK(ecode2)) {
31436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31437 }
31438 arg2 = static_cast< int >(val2);
31439 }
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 (arg1)->Center(arg2);
31443 wxPyEndAllowThreads(__tstate);
31444 if (PyErr_Occurred()) SWIG_fail;
31445 }
31446 resultobj = SWIG_Py_Void();
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31454 PyObject *resultobj = 0;
31455 wxWindow *arg1 = (wxWindow *) 0 ;
31456 int arg2 = (int) wxBOTH ;
31457 void *argp1 = 0 ;
31458 int res1 = 0 ;
31459 int val2 ;
31460 int ecode2 = 0 ;
31461 PyObject * obj0 = 0 ;
31462 PyObject * obj1 = 0 ;
31463 char * kwnames[] = {
31464 (char *) "self",(char *) "dir", NULL
31465 };
31466
31467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31469 if (!SWIG_IsOK(res1)) {
31470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31471 }
31472 arg1 = reinterpret_cast< wxWindow * >(argp1);
31473 if (obj1) {
31474 ecode2 = SWIG_AsVal_int(obj1, &val2);
31475 if (!SWIG_IsOK(ecode2)) {
31476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31477 }
31478 arg2 = static_cast< int >(val2);
31479 }
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 (arg1)->CenterOnParent(arg2);
31483 wxPyEndAllowThreads(__tstate);
31484 if (PyErr_Occurred()) SWIG_fail;
31485 }
31486 resultobj = SWIG_Py_Void();
31487 return resultobj;
31488 fail:
31489 return NULL;
31490 }
31491
31492
31493 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31494 PyObject *resultobj = 0;
31495 wxWindow *arg1 = (wxWindow *) 0 ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 PyObject *swig_obj[1] ;
31499
31500 if (!args) SWIG_fail;
31501 swig_obj[0] = args;
31502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31503 if (!SWIG_IsOK(res1)) {
31504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31505 }
31506 arg1 = reinterpret_cast< wxWindow * >(argp1);
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 (arg1)->Fit();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 resultobj = SWIG_Py_Void();
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31521 PyObject *resultobj = 0;
31522 wxWindow *arg1 = (wxWindow *) 0 ;
31523 void *argp1 = 0 ;
31524 int res1 = 0 ;
31525 PyObject *swig_obj[1] ;
31526
31527 if (!args) SWIG_fail;
31528 swig_obj[0] = args;
31529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31530 if (!SWIG_IsOK(res1)) {
31531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31532 }
31533 arg1 = reinterpret_cast< wxWindow * >(argp1);
31534 {
31535 PyThreadState* __tstate = wxPyBeginAllowThreads();
31536 (arg1)->FitInside();
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 resultobj = SWIG_Py_Void();
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj = 0;
31549 wxWindow *arg1 = (wxWindow *) 0 ;
31550 int arg2 ;
31551 int arg3 ;
31552 int arg4 = (int) -1 ;
31553 int arg5 = (int) -1 ;
31554 int arg6 = (int) -1 ;
31555 int arg7 = (int) -1 ;
31556 void *argp1 = 0 ;
31557 int res1 = 0 ;
31558 int val2 ;
31559 int ecode2 = 0 ;
31560 int val3 ;
31561 int ecode3 = 0 ;
31562 int val4 ;
31563 int ecode4 = 0 ;
31564 int val5 ;
31565 int ecode5 = 0 ;
31566 int val6 ;
31567 int ecode6 = 0 ;
31568 int val7 ;
31569 int ecode7 = 0 ;
31570 PyObject * obj0 = 0 ;
31571 PyObject * obj1 = 0 ;
31572 PyObject * obj2 = 0 ;
31573 PyObject * obj3 = 0 ;
31574 PyObject * obj4 = 0 ;
31575 PyObject * obj5 = 0 ;
31576 PyObject * obj6 = 0 ;
31577 char * kwnames[] = {
31578 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31579 };
31580
31581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31583 if (!SWIG_IsOK(res1)) {
31584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31585 }
31586 arg1 = reinterpret_cast< wxWindow * >(argp1);
31587 ecode2 = SWIG_AsVal_int(obj1, &val2);
31588 if (!SWIG_IsOK(ecode2)) {
31589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31590 }
31591 arg2 = static_cast< int >(val2);
31592 ecode3 = SWIG_AsVal_int(obj2, &val3);
31593 if (!SWIG_IsOK(ecode3)) {
31594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31595 }
31596 arg3 = static_cast< int >(val3);
31597 if (obj3) {
31598 ecode4 = SWIG_AsVal_int(obj3, &val4);
31599 if (!SWIG_IsOK(ecode4)) {
31600 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31601 }
31602 arg4 = static_cast< int >(val4);
31603 }
31604 if (obj4) {
31605 ecode5 = SWIG_AsVal_int(obj4, &val5);
31606 if (!SWIG_IsOK(ecode5)) {
31607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31608 }
31609 arg5 = static_cast< int >(val5);
31610 }
31611 if (obj5) {
31612 ecode6 = SWIG_AsVal_int(obj5, &val6);
31613 if (!SWIG_IsOK(ecode6)) {
31614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31615 }
31616 arg6 = static_cast< int >(val6);
31617 }
31618 if (obj6) {
31619 ecode7 = SWIG_AsVal_int(obj6, &val7);
31620 if (!SWIG_IsOK(ecode7)) {
31621 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31622 }
31623 arg7 = static_cast< int >(val7);
31624 }
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 resultobj = SWIG_Py_Void();
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj = 0;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 wxSize *arg2 = 0 ;
31642 wxSize const &arg3_defvalue = wxDefaultSize ;
31643 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31644 wxSize const &arg4_defvalue = wxDefaultSize ;
31645 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31646 void *argp1 = 0 ;
31647 int res1 = 0 ;
31648 wxSize temp2 ;
31649 wxSize temp3 ;
31650 wxSize temp4 ;
31651 PyObject * obj0 = 0 ;
31652 PyObject * obj1 = 0 ;
31653 PyObject * obj2 = 0 ;
31654 PyObject * obj3 = 0 ;
31655 char * kwnames[] = {
31656 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31657 };
31658
31659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31661 if (!SWIG_IsOK(res1)) {
31662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31663 }
31664 arg1 = reinterpret_cast< wxWindow * >(argp1);
31665 {
31666 arg2 = &temp2;
31667 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31668 }
31669 if (obj2) {
31670 {
31671 arg3 = &temp3;
31672 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31673 }
31674 }
31675 if (obj3) {
31676 {
31677 arg4 = &temp4;
31678 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31679 }
31680 }
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 resultobj = SWIG_Py_Void();
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31695 PyObject *resultobj = 0;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 int arg2 ;
31698 int arg3 ;
31699 int arg4 = (int) -1 ;
31700 int arg5 = (int) -1 ;
31701 void *argp1 = 0 ;
31702 int res1 = 0 ;
31703 int val2 ;
31704 int ecode2 = 0 ;
31705 int val3 ;
31706 int ecode3 = 0 ;
31707 int val4 ;
31708 int ecode4 = 0 ;
31709 int val5 ;
31710 int ecode5 = 0 ;
31711 PyObject * obj0 = 0 ;
31712 PyObject * obj1 = 0 ;
31713 PyObject * obj2 = 0 ;
31714 PyObject * obj3 = 0 ;
31715 PyObject * obj4 = 0 ;
31716 char * kwnames[] = {
31717 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31718 };
31719
31720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31722 if (!SWIG_IsOK(res1)) {
31723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31724 }
31725 arg1 = reinterpret_cast< wxWindow * >(argp1);
31726 ecode2 = SWIG_AsVal_int(obj1, &val2);
31727 if (!SWIG_IsOK(ecode2)) {
31728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31729 }
31730 arg2 = static_cast< int >(val2);
31731 ecode3 = SWIG_AsVal_int(obj2, &val3);
31732 if (!SWIG_IsOK(ecode3)) {
31733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31734 }
31735 arg3 = static_cast< int >(val3);
31736 if (obj3) {
31737 ecode4 = SWIG_AsVal_int(obj3, &val4);
31738 if (!SWIG_IsOK(ecode4)) {
31739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31740 }
31741 arg4 = static_cast< int >(val4);
31742 }
31743 if (obj4) {
31744 ecode5 = SWIG_AsVal_int(obj4, &val5);
31745 if (!SWIG_IsOK(ecode5)) {
31746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31747 }
31748 arg5 = static_cast< int >(val5);
31749 }
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31753 wxPyEndAllowThreads(__tstate);
31754 if (PyErr_Occurred()) SWIG_fail;
31755 }
31756 resultobj = SWIG_Py_Void();
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj = 0;
31765 wxWindow *arg1 = (wxWindow *) 0 ;
31766 wxSize *arg2 = 0 ;
31767 wxSize const &arg3_defvalue = wxDefaultSize ;
31768 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31769 void *argp1 = 0 ;
31770 int res1 = 0 ;
31771 wxSize temp2 ;
31772 wxSize temp3 ;
31773 PyObject * obj0 = 0 ;
31774 PyObject * obj1 = 0 ;
31775 PyObject * obj2 = 0 ;
31776 char * kwnames[] = {
31777 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31778 };
31779
31780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31782 if (!SWIG_IsOK(res1)) {
31783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31784 }
31785 arg1 = reinterpret_cast< wxWindow * >(argp1);
31786 {
31787 arg2 = &temp2;
31788 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31789 }
31790 if (obj2) {
31791 {
31792 arg3 = &temp3;
31793 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31794 }
31795 }
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 resultobj = SWIG_Py_Void();
31803 return resultobj;
31804 fail:
31805 return NULL;
31806 }
31807
31808
31809 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31810 PyObject *resultobj = 0;
31811 wxWindow *arg1 = (wxWindow *) 0 ;
31812 wxSize result;
31813 void *argp1 = 0 ;
31814 int res1 = 0 ;
31815 PyObject *swig_obj[1] ;
31816
31817 if (!args) SWIG_fail;
31818 swig_obj[0] = args;
31819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31820 if (!SWIG_IsOK(res1)) {
31821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31822 }
31823 arg1 = reinterpret_cast< wxWindow * >(argp1);
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 result = ((wxWindow const *)arg1)->GetMaxSize();
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31838 PyObject *resultobj = 0;
31839 wxWindow *arg1 = (wxWindow *) 0 ;
31840 wxSize result;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 PyObject *swig_obj[1] ;
31844
31845 if (!args) SWIG_fail;
31846 swig_obj[0] = args;
31847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31848 if (!SWIG_IsOK(res1)) {
31849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31850 }
31851 arg1 = reinterpret_cast< wxWindow * >(argp1);
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = ((wxWindow const *)arg1)->GetMinSize();
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31866 PyObject *resultobj = 0;
31867 wxWindow *arg1 = (wxWindow *) 0 ;
31868 wxSize *arg2 = 0 ;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 wxSize temp2 ;
31872 PyObject * obj0 = 0 ;
31873 PyObject * obj1 = 0 ;
31874 char * kwnames[] = {
31875 (char *) "self",(char *) "minSize", NULL
31876 };
31877
31878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31880 if (!SWIG_IsOK(res1)) {
31881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31882 }
31883 arg1 = reinterpret_cast< wxWindow * >(argp1);
31884 {
31885 arg2 = &temp2;
31886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31887 }
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 (arg1)->SetMinSize((wxSize const &)*arg2);
31891 wxPyEndAllowThreads(__tstate);
31892 if (PyErr_Occurred()) SWIG_fail;
31893 }
31894 resultobj = SWIG_Py_Void();
31895 return resultobj;
31896 fail:
31897 return NULL;
31898 }
31899
31900
31901 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31902 PyObject *resultobj = 0;
31903 wxWindow *arg1 = (wxWindow *) 0 ;
31904 wxSize *arg2 = 0 ;
31905 void *argp1 = 0 ;
31906 int res1 = 0 ;
31907 wxSize temp2 ;
31908 PyObject * obj0 = 0 ;
31909 PyObject * obj1 = 0 ;
31910 char * kwnames[] = {
31911 (char *) "self",(char *) "maxSize", NULL
31912 };
31913
31914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31916 if (!SWIG_IsOK(res1)) {
31917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31918 }
31919 arg1 = reinterpret_cast< wxWindow * >(argp1);
31920 {
31921 arg2 = &temp2;
31922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31923 }
31924 {
31925 PyThreadState* __tstate = wxPyBeginAllowThreads();
31926 (arg1)->SetMaxSize((wxSize const &)*arg2);
31927 wxPyEndAllowThreads(__tstate);
31928 if (PyErr_Occurred()) SWIG_fail;
31929 }
31930 resultobj = SWIG_Py_Void();
31931 return resultobj;
31932 fail:
31933 return NULL;
31934 }
31935
31936
31937 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31938 PyObject *resultobj = 0;
31939 wxWindow *arg1 = (wxWindow *) 0 ;
31940 int result;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 PyObject *swig_obj[1] ;
31944
31945 if (!args) SWIG_fail;
31946 swig_obj[0] = args;
31947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31948 if (!SWIG_IsOK(res1)) {
31949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31950 }
31951 arg1 = reinterpret_cast< wxWindow * >(argp1);
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31955 wxPyEndAllowThreads(__tstate);
31956 if (PyErr_Occurred()) SWIG_fail;
31957 }
31958 resultobj = SWIG_From_int(static_cast< int >(result));
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 PyObject *resultobj = 0;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 int result;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 PyObject *swig_obj[1] ;
31972
31973 if (!args) SWIG_fail;
31974 swig_obj[0] = args;
31975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31978 }
31979 arg1 = reinterpret_cast< wxWindow * >(argp1);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_From_int(static_cast< int >(result));
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 int result;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 PyObject *swig_obj[1] ;
32000
32001 if (!args) SWIG_fail;
32002 swig_obj[0] = args;
32003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32004 if (!SWIG_IsOK(res1)) {
32005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32006 }
32007 arg1 = reinterpret_cast< wxWindow * >(argp1);
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_From_int(static_cast< int >(result));
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 int result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32034 }
32035 arg1 = reinterpret_cast< wxWindow * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_From_int(static_cast< int >(result));
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj = 0;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxSize *arg2 = 0 ;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 wxSize temp2 ;
32056 PyObject * obj0 = 0 ;
32057 PyObject * obj1 = 0 ;
32058 char * kwnames[] = {
32059 (char *) "self",(char *) "size", NULL
32060 };
32061
32062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32064 if (!SWIG_IsOK(res1)) {
32065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32066 }
32067 arg1 = reinterpret_cast< wxWindow * >(argp1);
32068 {
32069 arg2 = &temp2;
32070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_Py_Void();
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj = 0;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 int arg2 ;
32089 int arg3 ;
32090 void *argp1 = 0 ;
32091 int res1 = 0 ;
32092 int val2 ;
32093 int ecode2 = 0 ;
32094 int val3 ;
32095 int ecode3 = 0 ;
32096 PyObject * obj0 = 0 ;
32097 PyObject * obj1 = 0 ;
32098 PyObject * obj2 = 0 ;
32099 char * kwnames[] = {
32100 (char *) "self",(char *) "w",(char *) "h", NULL
32101 };
32102
32103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32105 if (!SWIG_IsOK(res1)) {
32106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32107 }
32108 arg1 = reinterpret_cast< wxWindow * >(argp1);
32109 ecode2 = SWIG_AsVal_int(obj1, &val2);
32110 if (!SWIG_IsOK(ecode2)) {
32111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32112 }
32113 arg2 = static_cast< int >(val2);
32114 ecode3 = SWIG_AsVal_int(obj2, &val3);
32115 if (!SWIG_IsOK(ecode3)) {
32116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32117 }
32118 arg3 = static_cast< int >(val3);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 (arg1)->SetVirtualSize(arg2,arg3);
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_Py_Void();
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxWindow *arg1 = (wxWindow *) 0 ;
32135 wxSize result;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 PyObject *swig_obj[1] ;
32139
32140 if (!args) SWIG_fail;
32141 swig_obj[0] = args;
32142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = ((wxWindow const *)arg1)->GetVirtualSize();
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 int *arg2 = (int *) 0 ;
32164 int *arg3 = (int *) 0 ;
32165 void *argp1 = 0 ;
32166 int res1 = 0 ;
32167 int temp2 ;
32168 int res2 = SWIG_TMPOBJ ;
32169 int temp3 ;
32170 int res3 = SWIG_TMPOBJ ;
32171 PyObject *swig_obj[1] ;
32172
32173 arg2 = &temp2;
32174 arg3 = &temp3;
32175 if (!args) SWIG_fail;
32176 swig_obj[0] = args;
32177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32178 if (!SWIG_IsOK(res1)) {
32179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32180 }
32181 arg1 = reinterpret_cast< wxWindow * >(argp1);
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 resultobj = SWIG_Py_Void();
32189 if (SWIG_IsTmpObj(res2)) {
32190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32191 } else {
32192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32194 }
32195 if (SWIG_IsTmpObj(res3)) {
32196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32197 } else {
32198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32200 }
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 wxSize result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 bool arg2 = (bool) true ;
32239 bool result;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 bool val2 ;
32243 int ecode2 = 0 ;
32244 PyObject * obj0 = 0 ;
32245 PyObject * obj1 = 0 ;
32246 char * kwnames[] = {
32247 (char *) "self",(char *) "show", NULL
32248 };
32249
32250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32252 if (!SWIG_IsOK(res1)) {
32253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32254 }
32255 arg1 = reinterpret_cast< wxWindow * >(argp1);
32256 if (obj1) {
32257 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32258 if (!SWIG_IsOK(ecode2)) {
32259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32260 }
32261 arg2 = static_cast< bool >(val2);
32262 }
32263 {
32264 PyThreadState* __tstate = wxPyBeginAllowThreads();
32265 result = (bool)(arg1)->Show(arg2);
32266 wxPyEndAllowThreads(__tstate);
32267 if (PyErr_Occurred()) SWIG_fail;
32268 }
32269 {
32270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32271 }
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32279 PyObject *resultobj = 0;
32280 wxWindow *arg1 = (wxWindow *) 0 ;
32281 bool result;
32282 void *argp1 = 0 ;
32283 int res1 = 0 ;
32284 PyObject *swig_obj[1] ;
32285
32286 if (!args) SWIG_fail;
32287 swig_obj[0] = args;
32288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32289 if (!SWIG_IsOK(res1)) {
32290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32291 }
32292 arg1 = reinterpret_cast< wxWindow * >(argp1);
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (bool)(arg1)->Hide();
32296 wxPyEndAllowThreads(__tstate);
32297 if (PyErr_Occurred()) SWIG_fail;
32298 }
32299 {
32300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32301 }
32302 return resultobj;
32303 fail:
32304 return NULL;
32305 }
32306
32307
32308 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32309 PyObject *resultobj = 0;
32310 wxWindow *arg1 = (wxWindow *) 0 ;
32311 bool arg2 = (bool) true ;
32312 bool result;
32313 void *argp1 = 0 ;
32314 int res1 = 0 ;
32315 bool val2 ;
32316 int ecode2 = 0 ;
32317 PyObject * obj0 = 0 ;
32318 PyObject * obj1 = 0 ;
32319 char * kwnames[] = {
32320 (char *) "self",(char *) "enable", NULL
32321 };
32322
32323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32325 if (!SWIG_IsOK(res1)) {
32326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32327 }
32328 arg1 = reinterpret_cast< wxWindow * >(argp1);
32329 if (obj1) {
32330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32331 if (!SWIG_IsOK(ecode2)) {
32332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32333 }
32334 arg2 = static_cast< bool >(val2);
32335 }
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (bool)(arg1)->Enable(arg2);
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 {
32343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32344 }
32345 return resultobj;
32346 fail:
32347 return NULL;
32348 }
32349
32350
32351 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32352 PyObject *resultobj = 0;
32353 wxWindow *arg1 = (wxWindow *) 0 ;
32354 bool result;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 PyObject *swig_obj[1] ;
32358
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32364 }
32365 arg1 = reinterpret_cast< wxWindow * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (bool)(arg1)->Disable();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 {
32373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32374 }
32375 return resultobj;
32376 fail:
32377 return NULL;
32378 }
32379
32380
32381 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32382 PyObject *resultobj = 0;
32383 wxWindow *arg1 = (wxWindow *) 0 ;
32384 bool result;
32385 void *argp1 = 0 ;
32386 int res1 = 0 ;
32387 PyObject *swig_obj[1] ;
32388
32389 if (!args) SWIG_fail;
32390 swig_obj[0] = args;
32391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32392 if (!SWIG_IsOK(res1)) {
32393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32394 }
32395 arg1 = reinterpret_cast< wxWindow * >(argp1);
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 result = (bool)((wxWindow const *)arg1)->IsShown();
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 {
32403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32404 }
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32412 PyObject *resultobj = 0;
32413 wxWindow *arg1 = (wxWindow *) 0 ;
32414 bool result;
32415 void *argp1 = 0 ;
32416 int res1 = 0 ;
32417 PyObject *swig_obj[1] ;
32418
32419 if (!args) SWIG_fail;
32420 swig_obj[0] = args;
32421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32422 if (!SWIG_IsOK(res1)) {
32423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32424 }
32425 arg1 = reinterpret_cast< wxWindow * >(argp1);
32426 {
32427 PyThreadState* __tstate = wxPyBeginAllowThreads();
32428 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 {
32433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj = 0;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 long arg2 ;
32445 void *argp1 = 0 ;
32446 int res1 = 0 ;
32447 long val2 ;
32448 int ecode2 = 0 ;
32449 PyObject * obj0 = 0 ;
32450 PyObject * obj1 = 0 ;
32451 char * kwnames[] = {
32452 (char *) "self",(char *) "style", NULL
32453 };
32454
32455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32457 if (!SWIG_IsOK(res1)) {
32458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32459 }
32460 arg1 = reinterpret_cast< wxWindow * >(argp1);
32461 ecode2 = SWIG_AsVal_long(obj1, &val2);
32462 if (!SWIG_IsOK(ecode2)) {
32463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32464 }
32465 arg2 = static_cast< long >(val2);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 (arg1)->SetWindowStyleFlag(arg2);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_Py_Void();
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32480 PyObject *resultobj = 0;
32481 wxWindow *arg1 = (wxWindow *) 0 ;
32482 long result;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 PyObject *swig_obj[1] ;
32486
32487 if (!args) SWIG_fail;
32488 swig_obj[0] = args;
32489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32490 if (!SWIG_IsOK(res1)) {
32491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32492 }
32493 arg1 = reinterpret_cast< wxWindow * >(argp1);
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 resultobj = SWIG_From_long(static_cast< long >(result));
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32508 PyObject *resultobj = 0;
32509 wxWindow *arg1 = (wxWindow *) 0 ;
32510 int arg2 ;
32511 bool result;
32512 void *argp1 = 0 ;
32513 int res1 = 0 ;
32514 int val2 ;
32515 int ecode2 = 0 ;
32516 PyObject * obj0 = 0 ;
32517 PyObject * obj1 = 0 ;
32518 char * kwnames[] = {
32519 (char *) "self",(char *) "flag", NULL
32520 };
32521
32522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32524 if (!SWIG_IsOK(res1)) {
32525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32526 }
32527 arg1 = reinterpret_cast< wxWindow * >(argp1);
32528 ecode2 = SWIG_AsVal_int(obj1, &val2);
32529 if (!SWIG_IsOK(ecode2)) {
32530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32531 }
32532 arg2 = static_cast< int >(val2);
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 {
32540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32541 }
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32549 PyObject *resultobj = 0;
32550 wxWindow *arg1 = (wxWindow *) 0 ;
32551 bool result;
32552 void *argp1 = 0 ;
32553 int res1 = 0 ;
32554 PyObject *swig_obj[1] ;
32555
32556 if (!args) SWIG_fail;
32557 swig_obj[0] = args;
32558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32559 if (!SWIG_IsOK(res1)) {
32560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32561 }
32562 arg1 = reinterpret_cast< wxWindow * >(argp1);
32563 {
32564 PyThreadState* __tstate = wxPyBeginAllowThreads();
32565 result = (bool)((wxWindow const *)arg1)->IsRetained();
32566 wxPyEndAllowThreads(__tstate);
32567 if (PyErr_Occurred()) SWIG_fail;
32568 }
32569 {
32570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32571 }
32572 return resultobj;
32573 fail:
32574 return NULL;
32575 }
32576
32577
32578 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32579 PyObject *resultobj = 0;
32580 wxWindow *arg1 = (wxWindow *) 0 ;
32581 long arg2 ;
32582 void *argp1 = 0 ;
32583 int res1 = 0 ;
32584 long val2 ;
32585 int ecode2 = 0 ;
32586 PyObject * obj0 = 0 ;
32587 PyObject * obj1 = 0 ;
32588 char * kwnames[] = {
32589 (char *) "self",(char *) "exStyle", NULL
32590 };
32591
32592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32594 if (!SWIG_IsOK(res1)) {
32595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32596 }
32597 arg1 = reinterpret_cast< wxWindow * >(argp1);
32598 ecode2 = SWIG_AsVal_long(obj1, &val2);
32599 if (!SWIG_IsOK(ecode2)) {
32600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32601 }
32602 arg2 = static_cast< long >(val2);
32603 {
32604 PyThreadState* __tstate = wxPyBeginAllowThreads();
32605 (arg1)->SetExtraStyle(arg2);
32606 wxPyEndAllowThreads(__tstate);
32607 if (PyErr_Occurred()) SWIG_fail;
32608 }
32609 resultobj = SWIG_Py_Void();
32610 return resultobj;
32611 fail:
32612 return NULL;
32613 }
32614
32615
32616 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32617 PyObject *resultobj = 0;
32618 wxWindow *arg1 = (wxWindow *) 0 ;
32619 long result;
32620 void *argp1 = 0 ;
32621 int res1 = 0 ;
32622 PyObject *swig_obj[1] ;
32623
32624 if (!args) SWIG_fail;
32625 swig_obj[0] = args;
32626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32627 if (!SWIG_IsOK(res1)) {
32628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32629 }
32630 arg1 = reinterpret_cast< wxWindow * >(argp1);
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_From_long(static_cast< long >(result));
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 bool arg2 = (bool) true ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 bool val2 ;
32651 int ecode2 = 0 ;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 char * kwnames[] = {
32655 (char *) "self",(char *) "modal", NULL
32656 };
32657
32658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",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_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32662 }
32663 arg1 = reinterpret_cast< wxWindow * >(argp1);
32664 if (obj1) {
32665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32666 if (!SWIG_IsOK(ecode2)) {
32667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32668 }
32669 arg2 = static_cast< bool >(val2);
32670 }
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 (arg1)->MakeModal(arg2);
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 resultobj = SWIG_Py_Void();
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32685 PyObject *resultobj = 0;
32686 wxWindow *arg1 = (wxWindow *) 0 ;
32687 bool arg2 ;
32688 void *argp1 = 0 ;
32689 int res1 = 0 ;
32690 bool val2 ;
32691 int ecode2 = 0 ;
32692 PyObject * obj0 = 0 ;
32693 PyObject * obj1 = 0 ;
32694 char * kwnames[] = {
32695 (char *) "self",(char *) "enableTheme", NULL
32696 };
32697
32698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32700 if (!SWIG_IsOK(res1)) {
32701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32702 }
32703 arg1 = reinterpret_cast< wxWindow * >(argp1);
32704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32705 if (!SWIG_IsOK(ecode2)) {
32706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32707 }
32708 arg2 = static_cast< bool >(val2);
32709 {
32710 PyThreadState* __tstate = wxPyBeginAllowThreads();
32711 (arg1)->SetThemeEnabled(arg2);
32712 wxPyEndAllowThreads(__tstate);
32713 if (PyErr_Occurred()) SWIG_fail;
32714 }
32715 resultobj = SWIG_Py_Void();
32716 return resultobj;
32717 fail:
32718 return NULL;
32719 }
32720
32721
32722 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32723 PyObject *resultobj = 0;
32724 wxWindow *arg1 = (wxWindow *) 0 ;
32725 bool result;
32726 void *argp1 = 0 ;
32727 int res1 = 0 ;
32728 PyObject *swig_obj[1] ;
32729
32730 if (!args) SWIG_fail;
32731 swig_obj[0] = args;
32732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32733 if (!SWIG_IsOK(res1)) {
32734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32735 }
32736 arg1 = reinterpret_cast< wxWindow * >(argp1);
32737 {
32738 PyThreadState* __tstate = wxPyBeginAllowThreads();
32739 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32740 wxPyEndAllowThreads(__tstate);
32741 if (PyErr_Occurred()) SWIG_fail;
32742 }
32743 {
32744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32745 }
32746 return resultobj;
32747 fail:
32748 return NULL;
32749 }
32750
32751
32752 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32753 PyObject *resultobj = 0;
32754 wxWindow *arg1 = (wxWindow *) 0 ;
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_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32764 }
32765 arg1 = reinterpret_cast< wxWindow * >(argp1);
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 (arg1)->SetFocus();
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 void *argp1 = 0 ;
32783 int res1 = 0 ;
32784 PyObject *swig_obj[1] ;
32785
32786 if (!args) SWIG_fail;
32787 swig_obj[0] = args;
32788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32789 if (!SWIG_IsOK(res1)) {
32790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32791 }
32792 arg1 = reinterpret_cast< wxWindow * >(argp1);
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 (arg1)->SetFocusFromKbd();
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 resultobj = SWIG_Py_Void();
32800 return resultobj;
32801 fail:
32802 return NULL;
32803 }
32804
32805
32806 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32807 PyObject *resultobj = 0;
32808 wxWindow *result = 0 ;
32809
32810 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32811 {
32812 if (!wxPyCheckForApp()) SWIG_fail;
32813 PyThreadState* __tstate = wxPyBeginAllowThreads();
32814 result = (wxWindow *)wxWindow::FindFocus();
32815 wxPyEndAllowThreads(__tstate);
32816 if (PyErr_Occurred()) SWIG_fail;
32817 }
32818 {
32819 resultobj = wxPyMake_wxObject(result, 0);
32820 }
32821 return resultobj;
32822 fail:
32823 return NULL;
32824 }
32825
32826
32827 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32828 PyObject *resultobj = 0;
32829 wxWindow *arg1 = (wxWindow *) 0 ;
32830 bool result;
32831 void *argp1 = 0 ;
32832 int res1 = 0 ;
32833 PyObject *swig_obj[1] ;
32834
32835 if (!args) SWIG_fail;
32836 swig_obj[0] = args;
32837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res1)) {
32839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32840 }
32841 arg1 = reinterpret_cast< wxWindow * >(argp1);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 {
32849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32850 }
32851 return resultobj;
32852 fail:
32853 return NULL;
32854 }
32855
32856
32857 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32858 PyObject *resultobj = 0;
32859 wxWindow *arg1 = (wxWindow *) 0 ;
32860 bool result;
32861 void *argp1 = 0 ;
32862 int res1 = 0 ;
32863 PyObject *swig_obj[1] ;
32864
32865 if (!args) SWIG_fail;
32866 swig_obj[0] = args;
32867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32868 if (!SWIG_IsOK(res1)) {
32869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32870 }
32871 arg1 = reinterpret_cast< wxWindow * >(argp1);
32872 {
32873 PyThreadState* __tstate = wxPyBeginAllowThreads();
32874 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32875 wxPyEndAllowThreads(__tstate);
32876 if (PyErr_Occurred()) SWIG_fail;
32877 }
32878 {
32879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32880 }
32881 return resultobj;
32882 fail:
32883 return NULL;
32884 }
32885
32886
32887 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32888 PyObject *resultobj = 0;
32889 wxWindow *arg1 = (wxWindow *) 0 ;
32890 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32891 bool result;
32892 void *argp1 = 0 ;
32893 int res1 = 0 ;
32894 int val2 ;
32895 int ecode2 = 0 ;
32896 PyObject * obj0 = 0 ;
32897 PyObject * obj1 = 0 ;
32898 char * kwnames[] = {
32899 (char *) "self",(char *) "flags", NULL
32900 };
32901
32902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32904 if (!SWIG_IsOK(res1)) {
32905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32906 }
32907 arg1 = reinterpret_cast< wxWindow * >(argp1);
32908 if (obj1) {
32909 ecode2 = SWIG_AsVal_int(obj1, &val2);
32910 if (!SWIG_IsOK(ecode2)) {
32911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32912 }
32913 arg2 = static_cast< int >(val2);
32914 }
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (bool)(arg1)->Navigate(arg2);
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 {
32922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32923 }
32924 return resultobj;
32925 fail:
32926 return NULL;
32927 }
32928
32929
32930 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32931 PyObject *resultobj = 0;
32932 wxWindow *arg1 = (wxWindow *) 0 ;
32933 wxWindow *arg2 = (wxWindow *) 0 ;
32934 void *argp1 = 0 ;
32935 int res1 = 0 ;
32936 void *argp2 = 0 ;
32937 int res2 = 0 ;
32938 PyObject * obj0 = 0 ;
32939 PyObject * obj1 = 0 ;
32940 char * kwnames[] = {
32941 (char *) "self",(char *) "win", NULL
32942 };
32943
32944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32946 if (!SWIG_IsOK(res1)) {
32947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32948 }
32949 arg1 = reinterpret_cast< wxWindow * >(argp1);
32950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32951 if (!SWIG_IsOK(res2)) {
32952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32953 }
32954 arg2 = reinterpret_cast< wxWindow * >(argp2);
32955 {
32956 PyThreadState* __tstate = wxPyBeginAllowThreads();
32957 (arg1)->MoveAfterInTabOrder(arg2);
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 resultobj = SWIG_Py_Void();
32962 return resultobj;
32963 fail:
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32969 PyObject *resultobj = 0;
32970 wxWindow *arg1 = (wxWindow *) 0 ;
32971 wxWindow *arg2 = (wxWindow *) 0 ;
32972 void *argp1 = 0 ;
32973 int res1 = 0 ;
32974 void *argp2 = 0 ;
32975 int res2 = 0 ;
32976 PyObject * obj0 = 0 ;
32977 PyObject * obj1 = 0 ;
32978 char * kwnames[] = {
32979 (char *) "self",(char *) "win", NULL
32980 };
32981
32982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32984 if (!SWIG_IsOK(res1)) {
32985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32986 }
32987 arg1 = reinterpret_cast< wxWindow * >(argp1);
32988 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32989 if (!SWIG_IsOK(res2)) {
32990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32991 }
32992 arg2 = reinterpret_cast< wxWindow * >(argp2);
32993 {
32994 PyThreadState* __tstate = wxPyBeginAllowThreads();
32995 (arg1)->MoveBeforeInTabOrder(arg2);
32996 wxPyEndAllowThreads(__tstate);
32997 if (PyErr_Occurred()) SWIG_fail;
32998 }
32999 resultobj = SWIG_Py_Void();
33000 return resultobj;
33001 fail:
33002 return NULL;
33003 }
33004
33005
33006 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33007 PyObject *resultobj = 0;
33008 wxWindow *arg1 = (wxWindow *) 0 ;
33009 PyObject *result = 0 ;
33010 void *argp1 = 0 ;
33011 int res1 = 0 ;
33012 PyObject *swig_obj[1] ;
33013
33014 if (!args) SWIG_fail;
33015 swig_obj[0] = args;
33016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33017 if (!SWIG_IsOK(res1)) {
33018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33019 }
33020 arg1 = reinterpret_cast< wxWindow * >(argp1);
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 result = (PyObject *)wxWindow_GetChildren(arg1);
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 resultobj = result;
33028 return resultobj;
33029 fail:
33030 return NULL;
33031 }
33032
33033
33034 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33035 PyObject *resultobj = 0;
33036 wxWindow *arg1 = (wxWindow *) 0 ;
33037 wxWindow *result = 0 ;
33038 void *argp1 = 0 ;
33039 int res1 = 0 ;
33040 PyObject *swig_obj[1] ;
33041
33042 if (!args) SWIG_fail;
33043 swig_obj[0] = args;
33044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 {
33056 resultobj = wxPyMake_wxObject(result, 0);
33057 }
33058 return resultobj;
33059 fail:
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *resultobj = 0;
33066 wxWindow *arg1 = (wxWindow *) 0 ;
33067 wxWindow *result = 0 ;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject *swig_obj[1] ;
33071
33072 if (!args) SWIG_fail;
33073 swig_obj[0] = args;
33074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33077 }
33078 arg1 = reinterpret_cast< wxWindow * >(argp1);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 {
33086 resultobj = wxPyMake_wxObject(result, 0);
33087 }
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33095 PyObject *resultobj = 0;
33096 wxWindow *arg1 = (wxWindow *) 0 ;
33097 bool result;
33098 void *argp1 = 0 ;
33099 int res1 = 0 ;
33100 PyObject *swig_obj[1] ;
33101
33102 if (!args) SWIG_fail;
33103 swig_obj[0] = args;
33104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33105 if (!SWIG_IsOK(res1)) {
33106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33107 }
33108 arg1 = reinterpret_cast< wxWindow * >(argp1);
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33112 wxPyEndAllowThreads(__tstate);
33113 if (PyErr_Occurred()) SWIG_fail;
33114 }
33115 {
33116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33117 }
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33125 PyObject *resultobj = 0;
33126 wxWindow *arg1 = (wxWindow *) 0 ;
33127 wxWindow *arg2 = (wxWindow *) 0 ;
33128 bool result;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 void *argp2 = 0 ;
33132 int res2 = 0 ;
33133 PyObject * obj0 = 0 ;
33134 PyObject * obj1 = 0 ;
33135 char * kwnames[] = {
33136 (char *) "self",(char *) "newParent", NULL
33137 };
33138
33139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res2)) {
33147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33148 }
33149 arg2 = reinterpret_cast< wxWindow * >(argp2);
33150 {
33151 PyThreadState* __tstate = wxPyBeginAllowThreads();
33152 result = (bool)(arg1)->Reparent(arg2);
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 {
33157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33158 }
33159 return resultobj;
33160 fail:
33161 return NULL;
33162 }
33163
33164
33165 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj = 0;
33167 wxWindow *arg1 = (wxWindow *) 0 ;
33168 wxWindow *arg2 = (wxWindow *) 0 ;
33169 void *argp1 = 0 ;
33170 int res1 = 0 ;
33171 void *argp2 = 0 ;
33172 int res2 = 0 ;
33173 PyObject * obj0 = 0 ;
33174 PyObject * obj1 = 0 ;
33175 char * kwnames[] = {
33176 (char *) "self",(char *) "child", NULL
33177 };
33178
33179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33181 if (!SWIG_IsOK(res1)) {
33182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33183 }
33184 arg1 = reinterpret_cast< wxWindow * >(argp1);
33185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33186 if (!SWIG_IsOK(res2)) {
33187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33188 }
33189 arg2 = reinterpret_cast< wxWindow * >(argp2);
33190 {
33191 PyThreadState* __tstate = wxPyBeginAllowThreads();
33192 (arg1)->AddChild(arg2);
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 resultobj = SWIG_Py_Void();
33197 return resultobj;
33198 fail:
33199 return NULL;
33200 }
33201
33202
33203 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33204 PyObject *resultobj = 0;
33205 wxWindow *arg1 = (wxWindow *) 0 ;
33206 wxWindow *arg2 = (wxWindow *) 0 ;
33207 void *argp1 = 0 ;
33208 int res1 = 0 ;
33209 void *argp2 = 0 ;
33210 int res2 = 0 ;
33211 PyObject * obj0 = 0 ;
33212 PyObject * obj1 = 0 ;
33213 char * kwnames[] = {
33214 (char *) "self",(char *) "child", NULL
33215 };
33216
33217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33219 if (!SWIG_IsOK(res1)) {
33220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33221 }
33222 arg1 = reinterpret_cast< wxWindow * >(argp1);
33223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33224 if (!SWIG_IsOK(res2)) {
33225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33226 }
33227 arg2 = reinterpret_cast< wxWindow * >(argp2);
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 (arg1)->RemoveChild(arg2);
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 resultobj = SWIG_Py_Void();
33235 return resultobj;
33236 fail:
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33242 PyObject *resultobj = 0;
33243 wxWindow *arg1 = (wxWindow *) 0 ;
33244 bool arg2 ;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 bool val2 ;
33248 int ecode2 = 0 ;
33249 PyObject * obj0 = 0 ;
33250 PyObject * obj1 = 0 ;
33251 char * kwnames[] = {
33252 (char *) "self",(char *) "on", NULL
33253 };
33254
33255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33257 if (!SWIG_IsOK(res1)) {
33258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33259 }
33260 arg1 = reinterpret_cast< wxWindow * >(argp1);
33261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33262 if (!SWIG_IsOK(ecode2)) {
33263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33264 }
33265 arg2 = static_cast< bool >(val2);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 (arg1)->SetDoubleBuffered(arg2);
33269 wxPyEndAllowThreads(__tstate);
33270 if (PyErr_Occurred()) SWIG_fail;
33271 }
33272 resultobj = SWIG_Py_Void();
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 long arg2 ;
33283 wxWindow *result = 0 ;
33284 void *argp1 = 0 ;
33285 int res1 = 0 ;
33286 long val2 ;
33287 int ecode2 = 0 ;
33288 PyObject * obj0 = 0 ;
33289 PyObject * obj1 = 0 ;
33290 char * kwnames[] = {
33291 (char *) "self",(char *) "winid", NULL
33292 };
33293
33294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33296 if (!SWIG_IsOK(res1)) {
33297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33298 }
33299 arg1 = reinterpret_cast< wxWindow * >(argp1);
33300 ecode2 = SWIG_AsVal_long(obj1, &val2);
33301 if (!SWIG_IsOK(ecode2)) {
33302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33303 }
33304 arg2 = static_cast< long >(val2);
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 result = (wxWindow *)(arg1)->FindWindow(arg2);
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxPyMake_wxObject(result, 0);
33313 }
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 wxString *arg2 = 0 ;
33324 wxWindow *result = 0 ;
33325 void *argp1 = 0 ;
33326 int res1 = 0 ;
33327 bool temp2 = false ;
33328 PyObject * obj0 = 0 ;
33329 PyObject * obj1 = 0 ;
33330 char * kwnames[] = {
33331 (char *) "self",(char *) "name", NULL
33332 };
33333
33334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33336 if (!SWIG_IsOK(res1)) {
33337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33338 }
33339 arg1 = reinterpret_cast< wxWindow * >(argp1);
33340 {
33341 arg2 = wxString_in_helper(obj1);
33342 if (arg2 == NULL) SWIG_fail;
33343 temp2 = true;
33344 }
33345 {
33346 PyThreadState* __tstate = wxPyBeginAllowThreads();
33347 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33348 wxPyEndAllowThreads(__tstate);
33349 if (PyErr_Occurred()) SWIG_fail;
33350 }
33351 {
33352 resultobj = wxPyMake_wxObject(result, 0);
33353 }
33354 {
33355 if (temp2)
33356 delete arg2;
33357 }
33358 return resultobj;
33359 fail:
33360 {
33361 if (temp2)
33362 delete arg2;
33363 }
33364 return NULL;
33365 }
33366
33367
33368 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33369 PyObject *resultobj = 0;
33370 wxWindow *arg1 = (wxWindow *) 0 ;
33371 wxEvtHandler *result = 0 ;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374 PyObject *swig_obj[1] ;
33375
33376 if (!args) SWIG_fail;
33377 swig_obj[0] = args;
33378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 {
33390 resultobj = wxPyMake_wxObject(result, 0);
33391 }
33392 return resultobj;
33393 fail:
33394 return NULL;
33395 }
33396
33397
33398 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33399 PyObject *resultobj = 0;
33400 wxWindow *arg1 = (wxWindow *) 0 ;
33401 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33402 void *argp1 = 0 ;
33403 int res1 = 0 ;
33404 void *argp2 = 0 ;
33405 int res2 = 0 ;
33406 PyObject * obj0 = 0 ;
33407 PyObject * obj1 = 0 ;
33408 char * kwnames[] = {
33409 (char *) "self",(char *) "handler", NULL
33410 };
33411
33412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33414 if (!SWIG_IsOK(res1)) {
33415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33416 }
33417 arg1 = reinterpret_cast< wxWindow * >(argp1);
33418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33419 if (!SWIG_IsOK(res2)) {
33420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33421 }
33422 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 (arg1)->SetEventHandler(arg2);
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_Py_Void();
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj = 0;
33438 wxWindow *arg1 = (wxWindow *) 0 ;
33439 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33440 void *argp1 = 0 ;
33441 int res1 = 0 ;
33442 void *argp2 = 0 ;
33443 int res2 = 0 ;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char * kwnames[] = {
33447 (char *) "self",(char *) "handler", NULL
33448 };
33449
33450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33457 if (!SWIG_IsOK(res2)) {
33458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33459 }
33460 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 (arg1)->PushEventHandler(arg2);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_Py_Void();
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33475 PyObject *resultobj = 0;
33476 wxWindow *arg1 = (wxWindow *) 0 ;
33477 bool arg2 = (bool) false ;
33478 wxEvtHandler *result = 0 ;
33479 void *argp1 = 0 ;
33480 int res1 = 0 ;
33481 bool val2 ;
33482 int ecode2 = 0 ;
33483 PyObject * obj0 = 0 ;
33484 PyObject * obj1 = 0 ;
33485 char * kwnames[] = {
33486 (char *) "self",(char *) "deleteHandler", NULL
33487 };
33488
33489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33493 }
33494 arg1 = reinterpret_cast< wxWindow * >(argp1);
33495 if (obj1) {
33496 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33497 if (!SWIG_IsOK(ecode2)) {
33498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33499 }
33500 arg2 = static_cast< bool >(val2);
33501 }
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = wxPyMake_wxObject(result, 0);
33510 }
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33521 bool result;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 void *argp2 = 0 ;
33525 int res2 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "self",(char *) "handler", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33539 if (!SWIG_IsOK(res2)) {
33540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33541 }
33542 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (bool)(arg1)->RemoveEventHandler(arg2);
33546 wxPyEndAllowThreads(__tstate);
33547 if (PyErr_Occurred()) SWIG_fail;
33548 }
33549 {
33550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33551 }
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 wxValidator *arg2 = 0 ;
33562 void *argp1 = 0 ;
33563 int res1 = 0 ;
33564 void *argp2 = 0 ;
33565 int res2 = 0 ;
33566 PyObject * obj0 = 0 ;
33567 PyObject * obj1 = 0 ;
33568 char * kwnames[] = {
33569 (char *) "self",(char *) "validator", NULL
33570 };
33571
33572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33574 if (!SWIG_IsOK(res1)) {
33575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33576 }
33577 arg1 = reinterpret_cast< wxWindow * >(argp1);
33578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33579 if (!SWIG_IsOK(res2)) {
33580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33581 }
33582 if (!argp2) {
33583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33584 }
33585 arg2 = reinterpret_cast< wxValidator * >(argp2);
33586 {
33587 PyThreadState* __tstate = wxPyBeginAllowThreads();
33588 (arg1)->SetValidator((wxValidator const &)*arg2);
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 resultobj = SWIG_Py_Void();
33593 return resultobj;
33594 fail:
33595 return NULL;
33596 }
33597
33598
33599 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33600 PyObject *resultobj = 0;
33601 wxWindow *arg1 = (wxWindow *) 0 ;
33602 wxValidator *result = 0 ;
33603 void *argp1 = 0 ;
33604 int res1 = 0 ;
33605 PyObject *swig_obj[1] ;
33606
33607 if (!args) SWIG_fail;
33608 swig_obj[0] = args;
33609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33610 if (!SWIG_IsOK(res1)) {
33611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33612 }
33613 arg1 = reinterpret_cast< wxWindow * >(argp1);
33614 {
33615 PyThreadState* __tstate = wxPyBeginAllowThreads();
33616 result = (wxValidator *)(arg1)->GetValidator();
33617 wxPyEndAllowThreads(__tstate);
33618 if (PyErr_Occurred()) SWIG_fail;
33619 }
33620 {
33621 resultobj = wxPyMake_wxObject(result, (bool)0);
33622 }
33623 return resultobj;
33624 fail:
33625 return NULL;
33626 }
33627
33628
33629 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33630 PyObject *resultobj = 0;
33631 wxWindow *arg1 = (wxWindow *) 0 ;
33632 bool result;
33633 void *argp1 = 0 ;
33634 int res1 = 0 ;
33635 PyObject *swig_obj[1] ;
33636
33637 if (!args) SWIG_fail;
33638 swig_obj[0] = args;
33639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33640 if (!SWIG_IsOK(res1)) {
33641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33642 }
33643 arg1 = reinterpret_cast< wxWindow * >(argp1);
33644 {
33645 PyThreadState* __tstate = wxPyBeginAllowThreads();
33646 result = (bool)(arg1)->Validate();
33647 wxPyEndAllowThreads(__tstate);
33648 if (PyErr_Occurred()) SWIG_fail;
33649 }
33650 {
33651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33652 }
33653 return resultobj;
33654 fail:
33655 return NULL;
33656 }
33657
33658
33659 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33660 PyObject *resultobj = 0;
33661 wxWindow *arg1 = (wxWindow *) 0 ;
33662 bool result;
33663 void *argp1 = 0 ;
33664 int res1 = 0 ;
33665 PyObject *swig_obj[1] ;
33666
33667 if (!args) SWIG_fail;
33668 swig_obj[0] = args;
33669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33672 }
33673 arg1 = reinterpret_cast< wxWindow * >(argp1);
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (bool)(arg1)->TransferDataToWindow();
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 {
33681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33682 }
33683 return resultobj;
33684 fail:
33685 return NULL;
33686 }
33687
33688
33689 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33690 PyObject *resultobj = 0;
33691 wxWindow *arg1 = (wxWindow *) 0 ;
33692 bool result;
33693 void *argp1 = 0 ;
33694 int res1 = 0 ;
33695 PyObject *swig_obj[1] ;
33696
33697 if (!args) SWIG_fail;
33698 swig_obj[0] = args;
33699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33700 if (!SWIG_IsOK(res1)) {
33701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33702 }
33703 arg1 = reinterpret_cast< wxWindow * >(argp1);
33704 {
33705 PyThreadState* __tstate = wxPyBeginAllowThreads();
33706 result = (bool)(arg1)->TransferDataFromWindow();
33707 wxPyEndAllowThreads(__tstate);
33708 if (PyErr_Occurred()) SWIG_fail;
33709 }
33710 {
33711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33712 }
33713 return resultobj;
33714 fail:
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33720 PyObject *resultobj = 0;
33721 wxWindow *arg1 = (wxWindow *) 0 ;
33722 void *argp1 = 0 ;
33723 int res1 = 0 ;
33724 PyObject *swig_obj[1] ;
33725
33726 if (!args) SWIG_fail;
33727 swig_obj[0] = args;
33728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33729 if (!SWIG_IsOK(res1)) {
33730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33731 }
33732 arg1 = reinterpret_cast< wxWindow * >(argp1);
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 (arg1)->InitDialog();
33736 wxPyEndAllowThreads(__tstate);
33737 if (PyErr_Occurred()) SWIG_fail;
33738 }
33739 resultobj = SWIG_Py_Void();
33740 return resultobj;
33741 fail:
33742 return NULL;
33743 }
33744
33745
33746 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33747 PyObject *resultobj = 0;
33748 wxWindow *arg1 = (wxWindow *) 0 ;
33749 wxAcceleratorTable *arg2 = 0 ;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 void *argp2 = 0 ;
33753 int res2 = 0 ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "accel", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33764 }
33765 arg1 = reinterpret_cast< wxWindow * >(argp1);
33766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33767 if (!SWIG_IsOK(res2)) {
33768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33769 }
33770 if (!argp2) {
33771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33772 }
33773 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 resultobj = SWIG_Py_Void();
33781 return resultobj;
33782 fail:
33783 return NULL;
33784 }
33785
33786
33787 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33788 PyObject *resultobj = 0;
33789 wxWindow *arg1 = (wxWindow *) 0 ;
33790 wxAcceleratorTable *result = 0 ;
33791 void *argp1 = 0 ;
33792 int res1 = 0 ;
33793 PyObject *swig_obj[1] ;
33794
33795 if (!args) SWIG_fail;
33796 swig_obj[0] = args;
33797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33798 if (!SWIG_IsOK(res1)) {
33799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33800 }
33801 arg1 = reinterpret_cast< wxWindow * >(argp1);
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 int arg2 ;
33819 int arg3 ;
33820 int arg4 ;
33821 bool result;
33822 void *argp1 = 0 ;
33823 int res1 = 0 ;
33824 int val2 ;
33825 int ecode2 = 0 ;
33826 int val3 ;
33827 int ecode3 = 0 ;
33828 int val4 ;
33829 int ecode4 = 0 ;
33830 PyObject * obj0 = 0 ;
33831 PyObject * obj1 = 0 ;
33832 PyObject * obj2 = 0 ;
33833 PyObject * obj3 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33842 }
33843 arg1 = reinterpret_cast< wxWindow * >(argp1);
33844 ecode2 = SWIG_AsVal_int(obj1, &val2);
33845 if (!SWIG_IsOK(ecode2)) {
33846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33847 }
33848 arg2 = static_cast< int >(val2);
33849 ecode3 = SWIG_AsVal_int(obj2, &val3);
33850 if (!SWIG_IsOK(ecode3)) {
33851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33852 }
33853 arg3 = static_cast< int >(val3);
33854 ecode4 = SWIG_AsVal_int(obj3, &val4);
33855 if (!SWIG_IsOK(ecode4)) {
33856 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33857 }
33858 arg4 = static_cast< int >(val4);
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 {
33866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 int arg2 ;
33878 bool result;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 int val2 ;
33882 int ecode2 = 0 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 char * kwnames[] = {
33886 (char *) "self",(char *) "hotkeyId", NULL
33887 };
33888
33889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33891 if (!SWIG_IsOK(res1)) {
33892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33893 }
33894 arg1 = reinterpret_cast< wxWindow * >(argp1);
33895 ecode2 = SWIG_AsVal_int(obj1, &val2);
33896 if (!SWIG_IsOK(ecode2)) {
33897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33898 }
33899 arg2 = static_cast< int >(val2);
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 {
33907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33908 }
33909 return resultobj;
33910 fail:
33911 return NULL;
33912 }
33913
33914
33915 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33916 PyObject *resultobj = 0;
33917 wxWindow *arg1 = (wxWindow *) 0 ;
33918 wxPoint *arg2 = 0 ;
33919 wxPoint result;
33920 void *argp1 = 0 ;
33921 int res1 = 0 ;
33922 wxPoint temp2 ;
33923 PyObject * obj0 = 0 ;
33924 PyObject * obj1 = 0 ;
33925 char * kwnames[] = {
33926 (char *) "self",(char *) "pt", NULL
33927 };
33928
33929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 {
33936 arg2 = &temp2;
33937 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33938 }
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33942 wxPyEndAllowThreads(__tstate);
33943 if (PyErr_Occurred()) SWIG_fail;
33944 }
33945 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33946 return resultobj;
33947 fail:
33948 return NULL;
33949 }
33950
33951
33952 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33953 PyObject *resultobj = 0;
33954 wxWindow *arg1 = (wxWindow *) 0 ;
33955 wxSize *arg2 = 0 ;
33956 wxSize result;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 wxSize temp2 ;
33960 PyObject * obj0 = 0 ;
33961 PyObject * obj1 = 0 ;
33962 char * kwnames[] = {
33963 (char *) "self",(char *) "sz", NULL
33964 };
33965
33966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33968 if (!SWIG_IsOK(res1)) {
33969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33970 }
33971 arg1 = reinterpret_cast< wxWindow * >(argp1);
33972 {
33973 arg2 = &temp2;
33974 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33975 }
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33983 return resultobj;
33984 fail:
33985 return NULL;
33986 }
33987
33988
33989 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33990 PyObject *resultobj = 0;
33991 wxWindow *arg1 = (wxWindow *) 0 ;
33992 wxPoint *arg2 = 0 ;
33993 wxPoint result;
33994 void *argp1 = 0 ;
33995 int res1 = 0 ;
33996 wxPoint temp2 ;
33997 PyObject * obj0 = 0 ;
33998 PyObject * obj1 = 0 ;
33999 char * kwnames[] = {
34000 (char *) "self",(char *) "pt", NULL
34001 };
34002
34003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34005 if (!SWIG_IsOK(res1)) {
34006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34007 }
34008 arg1 = reinterpret_cast< wxWindow * >(argp1);
34009 {
34010 arg2 = &temp2;
34011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34012 }
34013 {
34014 PyThreadState* __tstate = wxPyBeginAllowThreads();
34015 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34020 return resultobj;
34021 fail:
34022 return NULL;
34023 }
34024
34025
34026 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34027 PyObject *resultobj = 0;
34028 wxWindow *arg1 = (wxWindow *) 0 ;
34029 wxSize *arg2 = 0 ;
34030 wxSize result;
34031 void *argp1 = 0 ;
34032 int res1 = 0 ;
34033 wxSize temp2 ;
34034 PyObject * obj0 = 0 ;
34035 PyObject * obj1 = 0 ;
34036 char * kwnames[] = {
34037 (char *) "self",(char *) "sz", NULL
34038 };
34039
34040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34042 if (!SWIG_IsOK(res1)) {
34043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34044 }
34045 arg1 = reinterpret_cast< wxWindow * >(argp1);
34046 {
34047 arg2 = &temp2;
34048 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34049 }
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34053 wxPyEndAllowThreads(__tstate);
34054 if (PyErr_Occurred()) SWIG_fail;
34055 }
34056 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 wxPoint *arg2 = 0 ;
34067 wxPoint result;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 wxPoint temp2 ;
34071 PyObject * obj0 = 0 ;
34072 PyObject * obj1 = 0 ;
34073 char * kwnames[] = {
34074 (char *) "self",(char *) "pt", NULL
34075 };
34076
34077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34079 if (!SWIG_IsOK(res1)) {
34080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34081 }
34082 arg1 = reinterpret_cast< wxWindow * >(argp1);
34083 {
34084 arg2 = &temp2;
34085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34086 }
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj = 0;
34102 wxWindow *arg1 = (wxWindow *) 0 ;
34103 wxSize *arg2 = 0 ;
34104 wxSize result;
34105 void *argp1 = 0 ;
34106 int res1 = 0 ;
34107 wxSize temp2 ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 char * kwnames[] = {
34111 (char *) "self",(char *) "sz", NULL
34112 };
34113
34114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 arg2 = &temp2;
34122 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34123 }
34124 {
34125 PyThreadState* __tstate = wxPyBeginAllowThreads();
34126 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34131 return resultobj;
34132 fail:
34133 return NULL;
34134 }
34135
34136
34137 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj = 0;
34139 wxWindow *arg1 = (wxWindow *) 0 ;
34140 int arg2 ;
34141 int arg3 ;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 int val2 ;
34145 int ecode2 = 0 ;
34146 int val3 ;
34147 int ecode3 = 0 ;
34148 PyObject * obj0 = 0 ;
34149 PyObject * obj1 = 0 ;
34150 PyObject * obj2 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "x",(char *) "y", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34159 }
34160 arg1 = reinterpret_cast< wxWindow * >(argp1);
34161 ecode2 = SWIG_AsVal_int(obj1, &val2);
34162 if (!SWIG_IsOK(ecode2)) {
34163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34164 }
34165 arg2 = static_cast< int >(val2);
34166 ecode3 = SWIG_AsVal_int(obj2, &val3);
34167 if (!SWIG_IsOK(ecode3)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34169 }
34170 arg3 = static_cast< int >(val3);
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 (arg1)->WarpPointer(arg2,arg3);
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 resultobj = SWIG_Py_Void();
34178 return resultobj;
34179 fail:
34180 return NULL;
34181 }
34182
34183
34184 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34185 PyObject *resultobj = 0;
34186 wxWindow *arg1 = (wxWindow *) 0 ;
34187 void *argp1 = 0 ;
34188 int res1 = 0 ;
34189 PyObject *swig_obj[1] ;
34190
34191 if (!args) SWIG_fail;
34192 swig_obj[0] = args;
34193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34194 if (!SWIG_IsOK(res1)) {
34195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34196 }
34197 arg1 = reinterpret_cast< wxWindow * >(argp1);
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 (arg1)->CaptureMouse();
34201 wxPyEndAllowThreads(__tstate);
34202 if (PyErr_Occurred()) SWIG_fail;
34203 }
34204 resultobj = SWIG_Py_Void();
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 PyObject *swig_obj[1] ;
34217
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 (arg1)->ReleaseMouse();
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_Py_Void();
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxWindow *result = 0 ;
34241
34242 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34243 {
34244 if (!wxPyCheckForApp()) SWIG_fail;
34245 PyThreadState* __tstate = wxPyBeginAllowThreads();
34246 result = (wxWindow *)wxWindow::GetCapture();
34247 wxPyEndAllowThreads(__tstate);
34248 if (PyErr_Occurred()) SWIG_fail;
34249 }
34250 {
34251 resultobj = wxPyMake_wxObject(result, 0);
34252 }
34253 return resultobj;
34254 fail:
34255 return NULL;
34256 }
34257
34258
34259 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34260 PyObject *resultobj = 0;
34261 wxWindow *arg1 = (wxWindow *) 0 ;
34262 bool result;
34263 void *argp1 = 0 ;
34264 int res1 = 0 ;
34265 PyObject *swig_obj[1] ;
34266
34267 if (!args) SWIG_fail;
34268 swig_obj[0] = args;
34269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34270 if (!SWIG_IsOK(res1)) {
34271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34272 }
34273 arg1 = reinterpret_cast< wxWindow * >(argp1);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 result = (bool)((wxWindow const *)arg1)->HasCapture();
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 {
34281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34282 }
34283 return resultobj;
34284 fail:
34285 return NULL;
34286 }
34287
34288
34289 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34290 PyObject *resultobj = 0;
34291 wxWindow *arg1 = (wxWindow *) 0 ;
34292 bool arg2 = (bool) true ;
34293 wxRect *arg3 = (wxRect *) NULL ;
34294 void *argp1 = 0 ;
34295 int res1 = 0 ;
34296 bool val2 ;
34297 int ecode2 = 0 ;
34298 void *argp3 = 0 ;
34299 int res3 = 0 ;
34300 PyObject * obj0 = 0 ;
34301 PyObject * obj1 = 0 ;
34302 PyObject * obj2 = 0 ;
34303 char * kwnames[] = {
34304 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34305 };
34306
34307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34311 }
34312 arg1 = reinterpret_cast< wxWindow * >(argp1);
34313 if (obj1) {
34314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34315 if (!SWIG_IsOK(ecode2)) {
34316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34317 }
34318 arg2 = static_cast< bool >(val2);
34319 }
34320 if (obj2) {
34321 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34322 if (!SWIG_IsOK(res3)) {
34323 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34324 }
34325 arg3 = reinterpret_cast< wxRect * >(argp3);
34326 }
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 resultobj = SWIG_Py_Void();
34334 return resultobj;
34335 fail:
34336 return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34341 PyObject *resultobj = 0;
34342 wxWindow *arg1 = (wxWindow *) 0 ;
34343 wxRect *arg2 = 0 ;
34344 bool arg3 = (bool) true ;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 wxRect temp2 ;
34348 bool val3 ;
34349 int ecode3 = 0 ;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 PyObject * obj2 = 0 ;
34353 char * kwnames[] = {
34354 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34355 };
34356
34357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34359 if (!SWIG_IsOK(res1)) {
34360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34361 }
34362 arg1 = reinterpret_cast< wxWindow * >(argp1);
34363 {
34364 arg2 = &temp2;
34365 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34366 }
34367 if (obj2) {
34368 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34369 if (!SWIG_IsOK(ecode3)) {
34370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34371 }
34372 arg3 = static_cast< bool >(val3);
34373 }
34374 {
34375 PyThreadState* __tstate = wxPyBeginAllowThreads();
34376 (arg1)->RefreshRect((wxRect const &)*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_Update(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_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 (arg1)->Update();
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_ClearBackground(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_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34426 }
34427 arg1 = reinterpret_cast< wxWindow * >(argp1);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 (arg1)->ClearBackground();
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_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34442 PyObject *resultobj = 0;
34443 wxWindow *arg1 = (wxWindow *) 0 ;
34444 void *argp1 = 0 ;
34445 int res1 = 0 ;
34446 PyObject *swig_obj[1] ;
34447
34448 if (!args) SWIG_fail;
34449 swig_obj[0] = args;
34450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34451 if (!SWIG_IsOK(res1)) {
34452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34453 }
34454 arg1 = reinterpret_cast< wxWindow * >(argp1);
34455 {
34456 PyThreadState* __tstate = wxPyBeginAllowThreads();
34457 (arg1)->Freeze();
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 resultobj = SWIG_Py_Void();
34462 return resultobj;
34463 fail:
34464 return NULL;
34465 }
34466
34467
34468 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34469 PyObject *resultobj = 0;
34470 wxWindow *arg1 = (wxWindow *) 0 ;
34471 void *argp1 = 0 ;
34472 int res1 = 0 ;
34473 PyObject *swig_obj[1] ;
34474
34475 if (!args) SWIG_fail;
34476 swig_obj[0] = args;
34477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34478 if (!SWIG_IsOK(res1)) {
34479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34480 }
34481 arg1 = reinterpret_cast< wxWindow * >(argp1);
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 (arg1)->Thaw();
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 resultobj = SWIG_Py_Void();
34489 return resultobj;
34490 fail:
34491 return NULL;
34492 }
34493
34494
34495 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34496 PyObject *resultobj = 0;
34497 wxWindow *arg1 = (wxWindow *) 0 ;
34498 wxDC *arg2 = 0 ;
34499 void *argp1 = 0 ;
34500 int res1 = 0 ;
34501 void *argp2 = 0 ;
34502 int res2 = 0 ;
34503 PyObject * obj0 = 0 ;
34504 PyObject * obj1 = 0 ;
34505 char * kwnames[] = {
34506 (char *) "self",(char *) "dc", NULL
34507 };
34508
34509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34511 if (!SWIG_IsOK(res1)) {
34512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34513 }
34514 arg1 = reinterpret_cast< wxWindow * >(argp1);
34515 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34516 if (!SWIG_IsOK(res2)) {
34517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34518 }
34519 if (!argp2) {
34520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34521 }
34522 arg2 = reinterpret_cast< wxDC * >(argp2);
34523 {
34524 PyThreadState* __tstate = wxPyBeginAllowThreads();
34525 (arg1)->PrepareDC(*arg2);
34526 wxPyEndAllowThreads(__tstate);
34527 if (PyErr_Occurred()) SWIG_fail;
34528 }
34529 resultobj = SWIG_Py_Void();
34530 return resultobj;
34531 fail:
34532 return NULL;
34533 }
34534
34535
34536 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34537 PyObject *resultobj = 0;
34538 wxWindow *arg1 = (wxWindow *) 0 ;
34539 wxRegion *result = 0 ;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 PyObject *swig_obj[1] ;
34543
34544 if (!args) SWIG_fail;
34545 swig_obj[0] = args;
34546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34547 if (!SWIG_IsOK(res1)) {
34548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34549 }
34550 arg1 = reinterpret_cast< wxWindow * >(argp1);
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 {
34554 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34555 result = (wxRegion *) &_result_ref;
34556 }
34557 wxPyEndAllowThreads(__tstate);
34558 if (PyErr_Occurred()) SWIG_fail;
34559 }
34560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34568 PyObject *resultobj = 0;
34569 wxWindow *arg1 = (wxWindow *) 0 ;
34570 wxRect result;
34571 void *argp1 = 0 ;
34572 int res1 = 0 ;
34573 PyObject *swig_obj[1] ;
34574
34575 if (!args) SWIG_fail;
34576 swig_obj[0] = args;
34577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34578 if (!SWIG_IsOK(res1)) {
34579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34580 }
34581 arg1 = reinterpret_cast< wxWindow * >(argp1);
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 int arg2 ;
34599 int arg3 ;
34600 int arg4 = (int) 1 ;
34601 int arg5 = (int) 1 ;
34602 bool result;
34603 void *argp1 = 0 ;
34604 int res1 = 0 ;
34605 int val2 ;
34606 int ecode2 = 0 ;
34607 int val3 ;
34608 int ecode3 = 0 ;
34609 int val4 ;
34610 int ecode4 = 0 ;
34611 int val5 ;
34612 int ecode5 = 0 ;
34613 PyObject * obj0 = 0 ;
34614 PyObject * obj1 = 0 ;
34615 PyObject * obj2 = 0 ;
34616 PyObject * obj3 = 0 ;
34617 PyObject * obj4 = 0 ;
34618 char * kwnames[] = {
34619 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34620 };
34621
34622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 ecode2 = SWIG_AsVal_int(obj1, &val2);
34629 if (!SWIG_IsOK(ecode2)) {
34630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34631 }
34632 arg2 = static_cast< int >(val2);
34633 ecode3 = SWIG_AsVal_int(obj2, &val3);
34634 if (!SWIG_IsOK(ecode3)) {
34635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34636 }
34637 arg3 = static_cast< int >(val3);
34638 if (obj3) {
34639 ecode4 = SWIG_AsVal_int(obj3, &val4);
34640 if (!SWIG_IsOK(ecode4)) {
34641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34642 }
34643 arg4 = static_cast< int >(val4);
34644 }
34645 if (obj4) {
34646 ecode5 = SWIG_AsVal_int(obj4, &val5);
34647 if (!SWIG_IsOK(ecode5)) {
34648 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34649 }
34650 arg5 = static_cast< int >(val5);
34651 }
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 {
34659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34660 }
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34668 PyObject *resultobj = 0;
34669 wxWindow *arg1 = (wxWindow *) 0 ;
34670 wxPoint *arg2 = 0 ;
34671 bool result;
34672 void *argp1 = 0 ;
34673 int res1 = 0 ;
34674 wxPoint temp2 ;
34675 PyObject * obj0 = 0 ;
34676 PyObject * obj1 = 0 ;
34677 char * kwnames[] = {
34678 (char *) "self",(char *) "pt", NULL
34679 };
34680
34681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34685 }
34686 arg1 = reinterpret_cast< wxWindow * >(argp1);
34687 {
34688 arg2 = &temp2;
34689 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34690 }
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 {
34698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34699 }
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34707 PyObject *resultobj = 0;
34708 wxWindow *arg1 = (wxWindow *) 0 ;
34709 wxRect *arg2 = 0 ;
34710 bool result;
34711 void *argp1 = 0 ;
34712 int res1 = 0 ;
34713 wxRect temp2 ;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 char * kwnames[] = {
34717 (char *) "self",(char *) "rect", NULL
34718 };
34719
34720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34722 if (!SWIG_IsOK(res1)) {
34723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34724 }
34725 arg1 = reinterpret_cast< wxWindow * >(argp1);
34726 {
34727 arg2 = &temp2;
34728 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34729 }
34730 {
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 {
34737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34738 }
34739 return resultobj;
34740 fail:
34741 return NULL;
34742 }
34743
34744
34745 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34746 PyObject *resultobj = 0;
34747 wxWindow *arg1 = (wxWindow *) 0 ;
34748 SwigValueWrapper<wxVisualAttributes > result;
34749 void *argp1 = 0 ;
34750 int res1 = 0 ;
34751 PyObject *swig_obj[1] ;
34752
34753 if (!args) SWIG_fail;
34754 swig_obj[0] = args;
34755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34756 if (!SWIG_IsOK(res1)) {
34757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34758 }
34759 arg1 = reinterpret_cast< wxWindow * >(argp1);
34760 {
34761 PyThreadState* __tstate = wxPyBeginAllowThreads();
34762 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34763 wxPyEndAllowThreads(__tstate);
34764 if (PyErr_Occurred()) SWIG_fail;
34765 }
34766 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34767 return resultobj;
34768 fail:
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34774 PyObject *resultobj = 0;
34775 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34776 SwigValueWrapper<wxVisualAttributes > result;
34777 int val1 ;
34778 int ecode1 = 0 ;
34779 PyObject * obj0 = 0 ;
34780 char * kwnames[] = {
34781 (char *) "variant", NULL
34782 };
34783
34784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34785 if (obj0) {
34786 ecode1 = SWIG_AsVal_int(obj0, &val1);
34787 if (!SWIG_IsOK(ecode1)) {
34788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34789 }
34790 arg1 = static_cast< wxWindowVariant >(val1);
34791 }
34792 {
34793 if (!wxPyCheckForApp()) SWIG_fail;
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 result = wxWindow::GetClassDefaultAttributes(arg1);
34796 wxPyEndAllowThreads(__tstate);
34797 if (PyErr_Occurred()) SWIG_fail;
34798 }
34799 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34807 PyObject *resultobj = 0;
34808 wxWindow *arg1 = (wxWindow *) 0 ;
34809 wxColour *arg2 = 0 ;
34810 bool result;
34811 void *argp1 = 0 ;
34812 int res1 = 0 ;
34813 wxColour temp2 ;
34814 PyObject * obj0 = 0 ;
34815 PyObject * obj1 = 0 ;
34816 char * kwnames[] = {
34817 (char *) "self",(char *) "colour", NULL
34818 };
34819
34820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34822 if (!SWIG_IsOK(res1)) {
34823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34824 }
34825 arg1 = reinterpret_cast< wxWindow * >(argp1);
34826 {
34827 arg2 = &temp2;
34828 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34829 }
34830 {
34831 PyThreadState* __tstate = wxPyBeginAllowThreads();
34832 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34833 wxPyEndAllowThreads(__tstate);
34834 if (PyErr_Occurred()) SWIG_fail;
34835 }
34836 {
34837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34838 }
34839 return resultobj;
34840 fail:
34841 return NULL;
34842 }
34843
34844
34845 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34846 PyObject *resultobj = 0;
34847 wxWindow *arg1 = (wxWindow *) 0 ;
34848 wxColour *arg2 = 0 ;
34849 void *argp1 = 0 ;
34850 int res1 = 0 ;
34851 wxColour temp2 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 char * kwnames[] = {
34855 (char *) "self",(char *) "colour", NULL
34856 };
34857
34858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34862 }
34863 arg1 = reinterpret_cast< wxWindow * >(argp1);
34864 {
34865 arg2 = &temp2;
34866 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34867 }
34868 {
34869 PyThreadState* __tstate = wxPyBeginAllowThreads();
34870 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34871 wxPyEndAllowThreads(__tstate);
34872 if (PyErr_Occurred()) SWIG_fail;
34873 }
34874 resultobj = SWIG_Py_Void();
34875 return resultobj;
34876 fail:
34877 return NULL;
34878 }
34879
34880
34881 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34882 PyObject *resultobj = 0;
34883 wxWindow *arg1 = (wxWindow *) 0 ;
34884 wxColour *arg2 = 0 ;
34885 bool result;
34886 void *argp1 = 0 ;
34887 int res1 = 0 ;
34888 wxColour temp2 ;
34889 PyObject * obj0 = 0 ;
34890 PyObject * obj1 = 0 ;
34891 char * kwnames[] = {
34892 (char *) "self",(char *) "colour", NULL
34893 };
34894
34895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34897 if (!SWIG_IsOK(res1)) {
34898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34899 }
34900 arg1 = reinterpret_cast< wxWindow * >(argp1);
34901 {
34902 arg2 = &temp2;
34903 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34904 }
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 {
34912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34913 }
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34921 PyObject *resultobj = 0;
34922 wxWindow *arg1 = (wxWindow *) 0 ;
34923 wxColour *arg2 = 0 ;
34924 void *argp1 = 0 ;
34925 int res1 = 0 ;
34926 wxColour temp2 ;
34927 PyObject * obj0 = 0 ;
34928 PyObject * obj1 = 0 ;
34929 char * kwnames[] = {
34930 (char *) "self",(char *) "colour", NULL
34931 };
34932
34933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34937 }
34938 arg1 = reinterpret_cast< wxWindow * >(argp1);
34939 {
34940 arg2 = &temp2;
34941 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34942 }
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 resultobj = SWIG_Py_Void();
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34957 PyObject *resultobj = 0;
34958 wxWindow *arg1 = (wxWindow *) 0 ;
34959 wxColour result;
34960 void *argp1 = 0 ;
34961 int res1 = 0 ;
34962 PyObject *swig_obj[1] ;
34963
34964 if (!args) SWIG_fail;
34965 swig_obj[0] = args;
34966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34967 if (!SWIG_IsOK(res1)) {
34968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34969 }
34970 arg1 = reinterpret_cast< wxWindow * >(argp1);
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34985 PyObject *resultobj = 0;
34986 wxWindow *arg1 = (wxWindow *) 0 ;
34987 wxColour result;
34988 void *argp1 = 0 ;
34989 int res1 = 0 ;
34990 PyObject *swig_obj[1] ;
34991
34992 if (!args) SWIG_fail;
34993 swig_obj[0] = args;
34994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34995 if (!SWIG_IsOK(res1)) {
34996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34997 }
34998 arg1 = reinterpret_cast< wxWindow * >(argp1);
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = ((wxWindow const *)arg1)->GetForegroundColour();
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 bool result;
35016 void *argp1 = 0 ;
35017 int res1 = 0 ;
35018 PyObject *swig_obj[1] ;
35019
35020 if (!args) SWIG_fail;
35021 swig_obj[0] = args;
35022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35025 }
35026 arg1 = reinterpret_cast< wxWindow * >(argp1);
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35030 wxPyEndAllowThreads(__tstate);
35031 if (PyErr_Occurred()) SWIG_fail;
35032 }
35033 {
35034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35035 }
35036 return resultobj;
35037 fail:
35038 return NULL;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35043 PyObject *resultobj = 0;
35044 wxWindow *arg1 = (wxWindow *) 0 ;
35045 bool result;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 PyObject *swig_obj[1] ;
35049
35050 if (!args) SWIG_fail;
35051 swig_obj[0] = args;
35052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35055 }
35056 arg1 = reinterpret_cast< wxWindow * >(argp1);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 {
35064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35065 }
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxBackgroundStyle arg2 ;
35076 bool result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 int val2 ;
35080 int ecode2 = 0 ;
35081 PyObject * obj0 = 0 ;
35082 PyObject * obj1 = 0 ;
35083 char * kwnames[] = {
35084 (char *) "self",(char *) "style", NULL
35085 };
35086
35087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35089 if (!SWIG_IsOK(res1)) {
35090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35091 }
35092 arg1 = reinterpret_cast< wxWindow * >(argp1);
35093 ecode2 = SWIG_AsVal_int(obj1, &val2);
35094 if (!SWIG_IsOK(ecode2)) {
35095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35096 }
35097 arg2 = static_cast< wxBackgroundStyle >(val2);
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35101 wxPyEndAllowThreads(__tstate);
35102 if (PyErr_Occurred()) SWIG_fail;
35103 }
35104 {
35105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35106 }
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35114 PyObject *resultobj = 0;
35115 wxWindow *arg1 = (wxWindow *) 0 ;
35116 wxBackgroundStyle result;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 PyObject *swig_obj[1] ;
35120
35121 if (!args) SWIG_fail;
35122 swig_obj[0] = args;
35123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35126 }
35127 arg1 = reinterpret_cast< wxWindow * >(argp1);
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 resultobj = SWIG_From_int(static_cast< int >(result));
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35142 PyObject *resultobj = 0;
35143 wxWindow *arg1 = (wxWindow *) 0 ;
35144 bool result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 PyObject *swig_obj[1] ;
35148
35149 if (!args) SWIG_fail;
35150 swig_obj[0] = args;
35151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 result = (bool)(arg1)->HasTransparentBackground();
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 {
35163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35164 }
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35172 PyObject *resultobj = 0;
35173 wxWindow *arg1 = (wxWindow *) 0 ;
35174 wxCursor *arg2 = 0 ;
35175 bool result;
35176 void *argp1 = 0 ;
35177 int res1 = 0 ;
35178 void *argp2 = 0 ;
35179 int res2 = 0 ;
35180 PyObject * obj0 = 0 ;
35181 PyObject * obj1 = 0 ;
35182 char * kwnames[] = {
35183 (char *) "self",(char *) "cursor", NULL
35184 };
35185
35186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35193 if (!SWIG_IsOK(res2)) {
35194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35195 }
35196 if (!argp2) {
35197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35198 }
35199 arg2 = reinterpret_cast< wxCursor * >(argp2);
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 {
35207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35208 }
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 wxCursor 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_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35228 }
35229 arg1 = reinterpret_cast< wxWindow * >(argp1);
35230 {
35231 PyThreadState* __tstate = wxPyBeginAllowThreads();
35232 result = (arg1)->GetCursor();
35233 wxPyEndAllowThreads(__tstate);
35234 if (PyErr_Occurred()) SWIG_fail;
35235 }
35236 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35237 return resultobj;
35238 fail:
35239 return NULL;
35240 }
35241
35242
35243 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35244 PyObject *resultobj = 0;
35245 wxWindow *arg1 = (wxWindow *) 0 ;
35246 wxFont *arg2 = 0 ;
35247 bool result;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 void *argp2 = 0 ;
35251 int res2 = 0 ;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 char * kwnames[] = {
35255 (char *) "self",(char *) "font", NULL
35256 };
35257
35258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35260 if (!SWIG_IsOK(res1)) {
35261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35262 }
35263 arg1 = reinterpret_cast< wxWindow * >(argp1);
35264 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35265 if (!SWIG_IsOK(res2)) {
35266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35267 }
35268 if (!argp2) {
35269 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35270 }
35271 arg2 = reinterpret_cast< wxFont * >(argp2);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 {
35279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35280 }
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 wxFont *arg2 = 0 ;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 void *argp2 = 0 ;
35294 int res2 = 0 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "font", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35308 if (!SWIG_IsOK(res2)) {
35309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35310 }
35311 if (!argp2) {
35312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35313 }
35314 arg2 = reinterpret_cast< wxFont * >(argp2);
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 (arg1)->SetOwnFont((wxFont const &)*arg2);
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 resultobj = SWIG_Py_Void();
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35329 PyObject *resultobj = 0;
35330 wxWindow *arg1 = (wxWindow *) 0 ;
35331 wxFont result;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 PyObject *swig_obj[1] ;
35335
35336 if (!args) SWIG_fail;
35337 swig_obj[0] = args;
35338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35341 }
35342 arg1 = reinterpret_cast< wxWindow * >(argp1);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (arg1)->GetFont();
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 wxCaret *arg2 = (wxCaret *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 int res2 = 0 ;
35363 PyObject * obj0 = 0 ;
35364 PyObject * obj1 = 0 ;
35365 char * kwnames[] = {
35366 (char *) "self",(char *) "caret", NULL
35367 };
35368
35369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35373 }
35374 arg1 = reinterpret_cast< wxWindow * >(argp1);
35375 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35376 if (!SWIG_IsOK(res2)) {
35377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35378 }
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 (arg1)->SetCaret(arg2);
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_Py_Void();
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35393 PyObject *resultobj = 0;
35394 wxWindow *arg1 = (wxWindow *) 0 ;
35395 wxCaret *result = 0 ;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 PyObject *swig_obj[1] ;
35399
35400 if (!args) SWIG_fail;
35401 swig_obj[0] = args;
35402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35405 }
35406 arg1 = reinterpret_cast< wxWindow * >(argp1);
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 int result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 resultobj = SWIG_From_int(static_cast< int >(result));
35442 return resultobj;
35443 fail:
35444 return NULL;
35445 }
35446
35447
35448 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35449 PyObject *resultobj = 0;
35450 wxWindow *arg1 = (wxWindow *) 0 ;
35451 int result;
35452 void *argp1 = 0 ;
35453 int res1 = 0 ;
35454 PyObject *swig_obj[1] ;
35455
35456 if (!args) SWIG_fail;
35457 swig_obj[0] = args;
35458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35461 }
35462 arg1 = reinterpret_cast< wxWindow * >(argp1);
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 resultobj = SWIG_From_int(static_cast< int >(result));
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 wxString *arg2 = 0 ;
35480 int *arg3 = (int *) 0 ;
35481 int *arg4 = (int *) 0 ;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 bool temp2 = false ;
35485 int temp3 ;
35486 int res3 = SWIG_TMPOBJ ;
35487 int temp4 ;
35488 int res4 = SWIG_TMPOBJ ;
35489 PyObject * obj0 = 0 ;
35490 PyObject * obj1 = 0 ;
35491 char * kwnames[] = {
35492 (char *) "self",(char *) "string", NULL
35493 };
35494
35495 arg3 = &temp3;
35496 arg4 = &temp4;
35497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35499 if (!SWIG_IsOK(res1)) {
35500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35501 }
35502 arg1 = reinterpret_cast< wxWindow * >(argp1);
35503 {
35504 arg2 = wxString_in_helper(obj1);
35505 if (arg2 == NULL) SWIG_fail;
35506 temp2 = true;
35507 }
35508 {
35509 PyThreadState* __tstate = wxPyBeginAllowThreads();
35510 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35511 wxPyEndAllowThreads(__tstate);
35512 if (PyErr_Occurred()) SWIG_fail;
35513 }
35514 resultobj = SWIG_Py_Void();
35515 if (SWIG_IsTmpObj(res3)) {
35516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35517 } else {
35518 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35520 }
35521 if (SWIG_IsTmpObj(res4)) {
35522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35523 } else {
35524 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35526 }
35527 {
35528 if (temp2)
35529 delete arg2;
35530 }
35531 return resultobj;
35532 fail:
35533 {
35534 if (temp2)
35535 delete arg2;
35536 }
35537 return NULL;
35538 }
35539
35540
35541 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35542 PyObject *resultobj = 0;
35543 wxWindow *arg1 = (wxWindow *) 0 ;
35544 wxString *arg2 = 0 ;
35545 int *arg3 = (int *) 0 ;
35546 int *arg4 = (int *) 0 ;
35547 int *arg5 = (int *) 0 ;
35548 int *arg6 = (int *) 0 ;
35549 wxFont *arg7 = (wxFont *) NULL ;
35550 void *argp1 = 0 ;
35551 int res1 = 0 ;
35552 bool temp2 = false ;
35553 int temp3 ;
35554 int res3 = SWIG_TMPOBJ ;
35555 int temp4 ;
35556 int res4 = SWIG_TMPOBJ ;
35557 int temp5 ;
35558 int res5 = SWIG_TMPOBJ ;
35559 int temp6 ;
35560 int res6 = SWIG_TMPOBJ ;
35561 void *argp7 = 0 ;
35562 int res7 = 0 ;
35563 PyObject * obj0 = 0 ;
35564 PyObject * obj1 = 0 ;
35565 PyObject * obj2 = 0 ;
35566 char * kwnames[] = {
35567 (char *) "self",(char *) "string",(char *) "font", NULL
35568 };
35569
35570 arg3 = &temp3;
35571 arg4 = &temp4;
35572 arg5 = &temp5;
35573 arg6 = &temp6;
35574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35578 }
35579 arg1 = reinterpret_cast< wxWindow * >(argp1);
35580 {
35581 arg2 = wxString_in_helper(obj1);
35582 if (arg2 == NULL) SWIG_fail;
35583 temp2 = true;
35584 }
35585 if (obj2) {
35586 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35587 if (!SWIG_IsOK(res7)) {
35588 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35589 }
35590 arg7 = reinterpret_cast< wxFont * >(argp7);
35591 }
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 resultobj = SWIG_Py_Void();
35599 if (SWIG_IsTmpObj(res3)) {
35600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35601 } else {
35602 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35604 }
35605 if (SWIG_IsTmpObj(res4)) {
35606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35607 } else {
35608 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35610 }
35611 if (SWIG_IsTmpObj(res5)) {
35612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35613 } else {
35614 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35616 }
35617 if (SWIG_IsTmpObj(res6)) {
35618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35619 } else {
35620 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35622 }
35623 {
35624 if (temp2)
35625 delete arg2;
35626 }
35627 return resultobj;
35628 fail:
35629 {
35630 if (temp2)
35631 delete arg2;
35632 }
35633 return NULL;
35634 }
35635
35636
35637 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35638 PyObject *resultobj = 0;
35639 wxWindow *arg1 = (wxWindow *) 0 ;
35640 int *arg2 = (int *) 0 ;
35641 int *arg3 = (int *) 0 ;
35642 void *argp1 = 0 ;
35643 int res1 = 0 ;
35644 int temp2 ;
35645 int res2 = 0 ;
35646 int temp3 ;
35647 int res3 = 0 ;
35648 PyObject * obj0 = 0 ;
35649 PyObject * obj1 = 0 ;
35650 PyObject * obj2 = 0 ;
35651 char * kwnames[] = {
35652 (char *) "self",(char *) "x",(char *) "y", NULL
35653 };
35654
35655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35662 int val;
35663 int ecode = SWIG_AsVal_int(obj1, &val);
35664 if (!SWIG_IsOK(ecode)) {
35665 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35666 }
35667 temp2 = static_cast< int >(val);
35668 arg2 = &temp2;
35669 res2 = SWIG_AddTmpMask(ecode);
35670 }
35671 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35672 int val;
35673 int ecode = SWIG_AsVal_int(obj2, &val);
35674 if (!SWIG_IsOK(ecode)) {
35675 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35676 }
35677 temp3 = static_cast< int >(val);
35678 arg3 = &temp3;
35679 res3 = SWIG_AddTmpMask(ecode);
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 resultobj = SWIG_Py_Void();
35688 if (SWIG_IsTmpObj(res2)) {
35689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35690 } else {
35691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35693 }
35694 if (SWIG_IsTmpObj(res3)) {
35695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35696 } else {
35697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35699 }
35700 return resultobj;
35701 fail:
35702 return NULL;
35703 }
35704
35705
35706 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35707 PyObject *resultobj = 0;
35708 wxWindow *arg1 = (wxWindow *) 0 ;
35709 int *arg2 = (int *) 0 ;
35710 int *arg3 = (int *) 0 ;
35711 void *argp1 = 0 ;
35712 int res1 = 0 ;
35713 int temp2 ;
35714 int res2 = 0 ;
35715 int temp3 ;
35716 int res3 = 0 ;
35717 PyObject * obj0 = 0 ;
35718 PyObject * obj1 = 0 ;
35719 PyObject * obj2 = 0 ;
35720 char * kwnames[] = {
35721 (char *) "self",(char *) "x",(char *) "y", NULL
35722 };
35723
35724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35726 if (!SWIG_IsOK(res1)) {
35727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35728 }
35729 arg1 = reinterpret_cast< wxWindow * >(argp1);
35730 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35731 int val;
35732 int ecode = SWIG_AsVal_int(obj1, &val);
35733 if (!SWIG_IsOK(ecode)) {
35734 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35735 }
35736 temp2 = static_cast< int >(val);
35737 arg2 = &temp2;
35738 res2 = SWIG_AddTmpMask(ecode);
35739 }
35740 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35741 int val;
35742 int ecode = SWIG_AsVal_int(obj2, &val);
35743 if (!SWIG_IsOK(ecode)) {
35744 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35745 }
35746 temp3 = static_cast< int >(val);
35747 arg3 = &temp3;
35748 res3 = SWIG_AddTmpMask(ecode);
35749 }
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 resultobj = SWIG_Py_Void();
35757 if (SWIG_IsTmpObj(res2)) {
35758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35759 } else {
35760 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35762 }
35763 if (SWIG_IsTmpObj(res3)) {
35764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35765 } else {
35766 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj = 0;
35777 wxWindow *arg1 = (wxWindow *) 0 ;
35778 wxPoint *arg2 = 0 ;
35779 wxPoint result;
35780 void *argp1 = 0 ;
35781 int res1 = 0 ;
35782 wxPoint temp2 ;
35783 PyObject * obj0 = 0 ;
35784 PyObject * obj1 = 0 ;
35785 char * kwnames[] = {
35786 (char *) "self",(char *) "pt", NULL
35787 };
35788
35789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35791 if (!SWIG_IsOK(res1)) {
35792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35793 }
35794 arg1 = reinterpret_cast< wxWindow * >(argp1);
35795 {
35796 arg2 = &temp2;
35797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35798 }
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35813 PyObject *resultobj = 0;
35814 wxWindow *arg1 = (wxWindow *) 0 ;
35815 wxPoint *arg2 = 0 ;
35816 wxPoint result;
35817 void *argp1 = 0 ;
35818 int res1 = 0 ;
35819 wxPoint temp2 ;
35820 PyObject * obj0 = 0 ;
35821 PyObject * obj1 = 0 ;
35822 char * kwnames[] = {
35823 (char *) "self",(char *) "pt", NULL
35824 };
35825
35826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35828 if (!SWIG_IsOK(res1)) {
35829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35830 }
35831 arg1 = reinterpret_cast< wxWindow * >(argp1);
35832 {
35833 arg2 = &temp2;
35834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35835 }
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35850 PyObject *resultobj = 0;
35851 wxWindow *arg1 = (wxWindow *) 0 ;
35852 int arg2 ;
35853 int arg3 ;
35854 wxHitTest result;
35855 void *argp1 = 0 ;
35856 int res1 = 0 ;
35857 int val2 ;
35858 int ecode2 = 0 ;
35859 int val3 ;
35860 int ecode3 = 0 ;
35861 PyObject * obj0 = 0 ;
35862 PyObject * obj1 = 0 ;
35863 PyObject * obj2 = 0 ;
35864 char * kwnames[] = {
35865 (char *) "self",(char *) "x",(char *) "y", NULL
35866 };
35867
35868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35872 }
35873 arg1 = reinterpret_cast< wxWindow * >(argp1);
35874 ecode2 = SWIG_AsVal_int(obj1, &val2);
35875 if (!SWIG_IsOK(ecode2)) {
35876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35877 }
35878 arg2 = static_cast< int >(val2);
35879 ecode3 = SWIG_AsVal_int(obj2, &val3);
35880 if (!SWIG_IsOK(ecode3)) {
35881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35882 }
35883 arg3 = static_cast< int >(val3);
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 resultobj = SWIG_From_int(static_cast< int >(result));
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj = 0;
35899 wxWindow *arg1 = (wxWindow *) 0 ;
35900 wxPoint *arg2 = 0 ;
35901 wxHitTest result;
35902 void *argp1 = 0 ;
35903 int res1 = 0 ;
35904 wxPoint temp2 ;
35905 PyObject * obj0 = 0 ;
35906 PyObject * obj1 = 0 ;
35907 char * kwnames[] = {
35908 (char *) "self",(char *) "pt", NULL
35909 };
35910
35911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35913 if (!SWIG_IsOK(res1)) {
35914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35915 }
35916 arg1 = reinterpret_cast< wxWindow * >(argp1);
35917 {
35918 arg2 = &temp2;
35919 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35920 }
35921 {
35922 PyThreadState* __tstate = wxPyBeginAllowThreads();
35923 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 resultobj = SWIG_From_int(static_cast< int >(result));
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35935 PyObject *resultobj = 0;
35936 wxWindow *arg1 = (wxWindow *) 0 ;
35937 long arg2 ;
35938 wxBorder result;
35939 void *argp1 = 0 ;
35940 int res1 = 0 ;
35941 long val2 ;
35942 int ecode2 = 0 ;
35943
35944 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35946 if (!SWIG_IsOK(res1)) {
35947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35948 }
35949 arg1 = reinterpret_cast< wxWindow * >(argp1);
35950 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35951 if (!SWIG_IsOK(ecode2)) {
35952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35953 }
35954 arg2 = static_cast< long >(val2);
35955 {
35956 PyThreadState* __tstate = wxPyBeginAllowThreads();
35957 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 resultobj = SWIG_From_int(static_cast< int >(result));
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35969 PyObject *resultobj = 0;
35970 wxWindow *arg1 = (wxWindow *) 0 ;
35971 wxBorder result;
35972 void *argp1 = 0 ;
35973 int res1 = 0 ;
35974
35975 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35977 if (!SWIG_IsOK(res1)) {
35978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35979 }
35980 arg1 = reinterpret_cast< wxWindow * >(argp1);
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 resultobj = SWIG_From_int(static_cast< int >(result));
35988 return resultobj;
35989 fail:
35990 return NULL;
35991 }
35992
35993
35994 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35995 int argc;
35996 PyObject *argv[3];
35997
35998 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35999 --argc;
36000 if (argc == 1) {
36001 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36002 }
36003 if (argc == 2) {
36004 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36005 }
36006
36007 fail:
36008 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj = 0;
36015 wxWindow *arg1 = (wxWindow *) 0 ;
36016 long arg2 = (long) wxUPDATE_UI_NONE ;
36017 void *argp1 = 0 ;
36018 int res1 = 0 ;
36019 long val2 ;
36020 int ecode2 = 0 ;
36021 PyObject * obj0 = 0 ;
36022 PyObject * obj1 = 0 ;
36023 char * kwnames[] = {
36024 (char *) "self",(char *) "flags", NULL
36025 };
36026
36027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36029 if (!SWIG_IsOK(res1)) {
36030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36031 }
36032 arg1 = reinterpret_cast< wxWindow * >(argp1);
36033 if (obj1) {
36034 ecode2 = SWIG_AsVal_long(obj1, &val2);
36035 if (!SWIG_IsOK(ecode2)) {
36036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36037 }
36038 arg2 = static_cast< long >(val2);
36039 }
36040 {
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 (arg1)->UpdateWindowUI(arg2);
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 resultobj = SWIG_Py_Void();
36047 return resultobj;
36048 fail:
36049 return NULL;
36050 }
36051
36052
36053 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36054 PyObject *resultobj = 0;
36055 wxWindow *arg1 = (wxWindow *) 0 ;
36056 wxMenu *arg2 = (wxMenu *) 0 ;
36057 int arg3 = (int) -1 ;
36058 int arg4 = (int) -1 ;
36059 bool result;
36060 void *argp1 = 0 ;
36061 int res1 = 0 ;
36062 void *argp2 = 0 ;
36063 int res2 = 0 ;
36064 int val3 ;
36065 int ecode3 = 0 ;
36066 int val4 ;
36067 int ecode4 = 0 ;
36068 PyObject * obj0 = 0 ;
36069 PyObject * obj1 = 0 ;
36070 PyObject * obj2 = 0 ;
36071 PyObject * obj3 = 0 ;
36072 char * kwnames[] = {
36073 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36074 };
36075
36076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36078 if (!SWIG_IsOK(res1)) {
36079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36080 }
36081 arg1 = reinterpret_cast< wxWindow * >(argp1);
36082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36083 if (!SWIG_IsOK(res2)) {
36084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36085 }
36086 arg2 = reinterpret_cast< wxMenu * >(argp2);
36087 if (obj2) {
36088 ecode3 = SWIG_AsVal_int(obj2, &val3);
36089 if (!SWIG_IsOK(ecode3)) {
36090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36091 }
36092 arg3 = static_cast< int >(val3);
36093 }
36094 if (obj3) {
36095 ecode4 = SWIG_AsVal_int(obj3, &val4);
36096 if (!SWIG_IsOK(ecode4)) {
36097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36098 }
36099 arg4 = static_cast< int >(val4);
36100 }
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 {
36108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36109 }
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36117 PyObject *resultobj = 0;
36118 wxWindow *arg1 = (wxWindow *) 0 ;
36119 wxMenu *arg2 = (wxMenu *) 0 ;
36120 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36121 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36122 bool result;
36123 void *argp1 = 0 ;
36124 int res1 = 0 ;
36125 void *argp2 = 0 ;
36126 int res2 = 0 ;
36127 wxPoint temp3 ;
36128 PyObject * obj0 = 0 ;
36129 PyObject * obj1 = 0 ;
36130 PyObject * obj2 = 0 ;
36131 char * kwnames[] = {
36132 (char *) "self",(char *) "menu",(char *) "pos", NULL
36133 };
36134
36135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36137 if (!SWIG_IsOK(res1)) {
36138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36139 }
36140 arg1 = reinterpret_cast< wxWindow * >(argp1);
36141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36142 if (!SWIG_IsOK(res2)) {
36143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36144 }
36145 arg2 = reinterpret_cast< wxMenu * >(argp2);
36146 if (obj2) {
36147 {
36148 arg3 = &temp3;
36149 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36150 }
36151 }
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36168 PyObject *resultobj = 0;
36169 wxWindow *arg1 = (wxWindow *) 0 ;
36170 bool result;
36171 void *argp1 = 0 ;
36172 int res1 = 0 ;
36173 PyObject *swig_obj[1] ;
36174
36175 if (!args) SWIG_fail;
36176 swig_obj[0] = args;
36177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36178 if (!SWIG_IsOK(res1)) {
36179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36180 }
36181 arg1 = reinterpret_cast< wxWindow * >(argp1);
36182 {
36183 PyThreadState* __tstate = wxPyBeginAllowThreads();
36184 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36185 wxPyEndAllowThreads(__tstate);
36186 if (PyErr_Occurred()) SWIG_fail;
36187 }
36188 {
36189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36190 }
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36198 PyObject *resultobj = 0;
36199 wxWindow *arg1 = (wxWindow *) 0 ;
36200 long result;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 PyObject *swig_obj[1] ;
36204
36205 if (!args) SWIG_fail;
36206 swig_obj[0] = args;
36207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36208 if (!SWIG_IsOK(res1)) {
36209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36210 }
36211 arg1 = reinterpret_cast< wxWindow * >(argp1);
36212 {
36213 PyThreadState* __tstate = wxPyBeginAllowThreads();
36214 result = (long)wxWindow_GetHandle(arg1);
36215 wxPyEndAllowThreads(__tstate);
36216 if (PyErr_Occurred()) SWIG_fail;
36217 }
36218 resultobj = SWIG_From_long(static_cast< long >(result));
36219 return resultobj;
36220 fail:
36221 return NULL;
36222 }
36223
36224
36225 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36226 PyObject *resultobj = 0;
36227 wxWindow *arg1 = (wxWindow *) 0 ;
36228 long arg2 ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 long val2 ;
36232 int ecode2 = 0 ;
36233 PyObject * obj0 = 0 ;
36234 PyObject * obj1 = 0 ;
36235 char * kwnames[] = {
36236 (char *) "self",(char *) "handle", NULL
36237 };
36238
36239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36241 if (!SWIG_IsOK(res1)) {
36242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36243 }
36244 arg1 = reinterpret_cast< wxWindow * >(argp1);
36245 ecode2 = SWIG_AsVal_long(obj1, &val2);
36246 if (!SWIG_IsOK(ecode2)) {
36247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36248 }
36249 arg2 = static_cast< long >(val2);
36250 {
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 wxWindow_AssociateHandle(arg1,arg2);
36253 wxPyEndAllowThreads(__tstate);
36254 if (PyErr_Occurred()) SWIG_fail;
36255 }
36256 resultobj = SWIG_Py_Void();
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36264 PyObject *resultobj = 0;
36265 wxWindow *arg1 = (wxWindow *) 0 ;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 PyObject *swig_obj[1] ;
36269
36270 if (!args) SWIG_fail;
36271 swig_obj[0] = args;
36272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 (arg1)->DissociateHandle();
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 resultobj = SWIG_Py_Void();
36284 return resultobj;
36285 fail:
36286 return NULL;
36287 }
36288
36289
36290 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36291 PyObject *resultobj = 0;
36292 wxWindow *arg1 = (wxWindow *) 0 ;
36293 int arg2 ;
36294 bool result;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 int val2 ;
36298 int ecode2 = 0 ;
36299 PyObject * obj0 = 0 ;
36300 PyObject * obj1 = 0 ;
36301 char * kwnames[] = {
36302 (char *) "self",(char *) "orient", NULL
36303 };
36304
36305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36307 if (!SWIG_IsOK(res1)) {
36308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36309 }
36310 arg1 = reinterpret_cast< wxWindow * >(argp1);
36311 ecode2 = SWIG_AsVal_int(obj1, &val2);
36312 if (!SWIG_IsOK(ecode2)) {
36313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36314 }
36315 arg2 = static_cast< int >(val2);
36316 {
36317 PyThreadState* __tstate = wxPyBeginAllowThreads();
36318 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36324 }
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36332 PyObject *resultobj = 0;
36333 wxWindow *arg1 = (wxWindow *) 0 ;
36334 int arg2 ;
36335 int arg3 ;
36336 int arg4 ;
36337 int arg5 ;
36338 bool arg6 = (bool) true ;
36339 void *argp1 = 0 ;
36340 int res1 = 0 ;
36341 int val2 ;
36342 int ecode2 = 0 ;
36343 int val3 ;
36344 int ecode3 = 0 ;
36345 int val4 ;
36346 int ecode4 = 0 ;
36347 int val5 ;
36348 int ecode5 = 0 ;
36349 bool val6 ;
36350 int ecode6 = 0 ;
36351 PyObject * obj0 = 0 ;
36352 PyObject * obj1 = 0 ;
36353 PyObject * obj2 = 0 ;
36354 PyObject * obj3 = 0 ;
36355 PyObject * obj4 = 0 ;
36356 PyObject * obj5 = 0 ;
36357 char * kwnames[] = {
36358 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36359 };
36360
36361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36365 }
36366 arg1 = reinterpret_cast< wxWindow * >(argp1);
36367 ecode2 = SWIG_AsVal_int(obj1, &val2);
36368 if (!SWIG_IsOK(ecode2)) {
36369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36370 }
36371 arg2 = static_cast< int >(val2);
36372 ecode3 = SWIG_AsVal_int(obj2, &val3);
36373 if (!SWIG_IsOK(ecode3)) {
36374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36375 }
36376 arg3 = static_cast< int >(val3);
36377 ecode4 = SWIG_AsVal_int(obj3, &val4);
36378 if (!SWIG_IsOK(ecode4)) {
36379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36380 }
36381 arg4 = static_cast< int >(val4);
36382 ecode5 = SWIG_AsVal_int(obj4, &val5);
36383 if (!SWIG_IsOK(ecode5)) {
36384 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36385 }
36386 arg5 = static_cast< int >(val5);
36387 if (obj5) {
36388 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36389 if (!SWIG_IsOK(ecode6)) {
36390 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36391 }
36392 arg6 = static_cast< bool >(val6);
36393 }
36394 {
36395 PyThreadState* __tstate = wxPyBeginAllowThreads();
36396 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36397 wxPyEndAllowThreads(__tstate);
36398 if (PyErr_Occurred()) SWIG_fail;
36399 }
36400 resultobj = SWIG_Py_Void();
36401 return resultobj;
36402 fail:
36403 return NULL;
36404 }
36405
36406
36407 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36408 PyObject *resultobj = 0;
36409 wxWindow *arg1 = (wxWindow *) 0 ;
36410 int arg2 ;
36411 int arg3 ;
36412 bool arg4 = (bool) true ;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 int val2 ;
36416 int ecode2 = 0 ;
36417 int val3 ;
36418 int ecode3 = 0 ;
36419 bool val4 ;
36420 int ecode4 = 0 ;
36421 PyObject * obj0 = 0 ;
36422 PyObject * obj1 = 0 ;
36423 PyObject * obj2 = 0 ;
36424 PyObject * obj3 = 0 ;
36425 char * kwnames[] = {
36426 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36427 };
36428
36429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36431 if (!SWIG_IsOK(res1)) {
36432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36433 }
36434 arg1 = reinterpret_cast< wxWindow * >(argp1);
36435 ecode2 = SWIG_AsVal_int(obj1, &val2);
36436 if (!SWIG_IsOK(ecode2)) {
36437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36438 }
36439 arg2 = static_cast< int >(val2);
36440 ecode3 = SWIG_AsVal_int(obj2, &val3);
36441 if (!SWIG_IsOK(ecode3)) {
36442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36443 }
36444 arg3 = static_cast< int >(val3);
36445 if (obj3) {
36446 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36447 if (!SWIG_IsOK(ecode4)) {
36448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36449 }
36450 arg4 = static_cast< bool >(val4);
36451 }
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 (arg1)->SetScrollPos(arg2,arg3,arg4);
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 resultobj = SWIG_Py_Void();
36459 return resultobj;
36460 fail:
36461 return NULL;
36462 }
36463
36464
36465 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36466 PyObject *resultobj = 0;
36467 wxWindow *arg1 = (wxWindow *) 0 ;
36468 int arg2 ;
36469 int result;
36470 void *argp1 = 0 ;
36471 int res1 = 0 ;
36472 int val2 ;
36473 int ecode2 = 0 ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 char * kwnames[] = {
36477 (char *) "self",(char *) "orientation", NULL
36478 };
36479
36480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36482 if (!SWIG_IsOK(res1)) {
36483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36484 }
36485 arg1 = reinterpret_cast< wxWindow * >(argp1);
36486 ecode2 = SWIG_AsVal_int(obj1, &val2);
36487 if (!SWIG_IsOK(ecode2)) {
36488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36489 }
36490 arg2 = static_cast< int >(val2);
36491 {
36492 PyThreadState* __tstate = wxPyBeginAllowThreads();
36493 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36494 wxPyEndAllowThreads(__tstate);
36495 if (PyErr_Occurred()) SWIG_fail;
36496 }
36497 resultobj = SWIG_From_int(static_cast< int >(result));
36498 return resultobj;
36499 fail:
36500 return NULL;
36501 }
36502
36503
36504 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36505 PyObject *resultobj = 0;
36506 wxWindow *arg1 = (wxWindow *) 0 ;
36507 int arg2 ;
36508 int result;
36509 void *argp1 = 0 ;
36510 int res1 = 0 ;
36511 int val2 ;
36512 int ecode2 = 0 ;
36513 PyObject * obj0 = 0 ;
36514 PyObject * obj1 = 0 ;
36515 char * kwnames[] = {
36516 (char *) "self",(char *) "orientation", NULL
36517 };
36518
36519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36521 if (!SWIG_IsOK(res1)) {
36522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36523 }
36524 arg1 = reinterpret_cast< wxWindow * >(argp1);
36525 ecode2 = SWIG_AsVal_int(obj1, &val2);
36526 if (!SWIG_IsOK(ecode2)) {
36527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36528 }
36529 arg2 = static_cast< int >(val2);
36530 {
36531 PyThreadState* __tstate = wxPyBeginAllowThreads();
36532 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36533 wxPyEndAllowThreads(__tstate);
36534 if (PyErr_Occurred()) SWIG_fail;
36535 }
36536 resultobj = SWIG_From_int(static_cast< int >(result));
36537 return resultobj;
36538 fail:
36539 return NULL;
36540 }
36541
36542
36543 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36544 PyObject *resultobj = 0;
36545 wxWindow *arg1 = (wxWindow *) 0 ;
36546 int arg2 ;
36547 int result;
36548 void *argp1 = 0 ;
36549 int res1 = 0 ;
36550 int val2 ;
36551 int ecode2 = 0 ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char * kwnames[] = {
36555 (char *) "self",(char *) "orientation", NULL
36556 };
36557
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 ecode2 = SWIG_AsVal_int(obj1, &val2);
36565 if (!SWIG_IsOK(ecode2)) {
36566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36567 }
36568 arg2 = static_cast< int >(val2);
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36572 wxPyEndAllowThreads(__tstate);
36573 if (PyErr_Occurred()) SWIG_fail;
36574 }
36575 resultobj = SWIG_From_int(static_cast< int >(result));
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 int arg2 ;
36586 int arg3 ;
36587 wxRect *arg4 = (wxRect *) NULL ;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 int val2 ;
36591 int ecode2 = 0 ;
36592 int val3 ;
36593 int ecode3 = 0 ;
36594 void *argp4 = 0 ;
36595 int res4 = 0 ;
36596 PyObject * obj0 = 0 ;
36597 PyObject * obj1 = 0 ;
36598 PyObject * obj2 = 0 ;
36599 PyObject * obj3 = 0 ;
36600 char * kwnames[] = {
36601 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36602 };
36603
36604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 ecode2 = SWIG_AsVal_int(obj1, &val2);
36611 if (!SWIG_IsOK(ecode2)) {
36612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36613 }
36614 arg2 = static_cast< int >(val2);
36615 ecode3 = SWIG_AsVal_int(obj2, &val3);
36616 if (!SWIG_IsOK(ecode3)) {
36617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36618 }
36619 arg3 = static_cast< int >(val3);
36620 if (obj3) {
36621 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36622 if (!SWIG_IsOK(res4)) {
36623 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36624 }
36625 arg4 = reinterpret_cast< wxRect * >(argp4);
36626 }
36627 {
36628 PyThreadState* __tstate = wxPyBeginAllowThreads();
36629 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36630 wxPyEndAllowThreads(__tstate);
36631 if (PyErr_Occurred()) SWIG_fail;
36632 }
36633 resultobj = SWIG_Py_Void();
36634 return resultobj;
36635 fail:
36636 return NULL;
36637 }
36638
36639
36640 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36641 PyObject *resultobj = 0;
36642 wxWindow *arg1 = (wxWindow *) 0 ;
36643 int arg2 ;
36644 bool result;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 int val2 ;
36648 int ecode2 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 char * kwnames[] = {
36652 (char *) "self",(char *) "lines", NULL
36653 };
36654
36655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36659 }
36660 arg1 = reinterpret_cast< wxWindow * >(argp1);
36661 ecode2 = SWIG_AsVal_int(obj1, &val2);
36662 if (!SWIG_IsOK(ecode2)) {
36663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36664 }
36665 arg2 = static_cast< int >(val2);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 result = (bool)(arg1)->ScrollLines(arg2);
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36674 }
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 int arg2 ;
36685 bool result;
36686 void *argp1 = 0 ;
36687 int res1 = 0 ;
36688 int val2 ;
36689 int ecode2 = 0 ;
36690 PyObject * obj0 = 0 ;
36691 PyObject * obj1 = 0 ;
36692 char * kwnames[] = {
36693 (char *) "self",(char *) "pages", NULL
36694 };
36695
36696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36698 if (!SWIG_IsOK(res1)) {
36699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36700 }
36701 arg1 = reinterpret_cast< wxWindow * >(argp1);
36702 ecode2 = SWIG_AsVal_int(obj1, &val2);
36703 if (!SWIG_IsOK(ecode2)) {
36704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36705 }
36706 arg2 = static_cast< int >(val2);
36707 {
36708 PyThreadState* __tstate = wxPyBeginAllowThreads();
36709 result = (bool)(arg1)->ScrollPages(arg2);
36710 wxPyEndAllowThreads(__tstate);
36711 if (PyErr_Occurred()) SWIG_fail;
36712 }
36713 {
36714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36715 }
36716 return resultobj;
36717 fail:
36718 return NULL;
36719 }
36720
36721
36722 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36723 PyObject *resultobj = 0;
36724 wxWindow *arg1 = (wxWindow *) 0 ;
36725 bool result;
36726 void *argp1 = 0 ;
36727 int res1 = 0 ;
36728 PyObject *swig_obj[1] ;
36729
36730 if (!args) SWIG_fail;
36731 swig_obj[0] = args;
36732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36733 if (!SWIG_IsOK(res1)) {
36734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36735 }
36736 arg1 = reinterpret_cast< wxWindow * >(argp1);
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 result = (bool)(arg1)->LineUp();
36740 wxPyEndAllowThreads(__tstate);
36741 if (PyErr_Occurred()) SWIG_fail;
36742 }
36743 {
36744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36745 }
36746 return resultobj;
36747 fail:
36748 return NULL;
36749 }
36750
36751
36752 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36753 PyObject *resultobj = 0;
36754 wxWindow *arg1 = (wxWindow *) 0 ;
36755 bool result;
36756 void *argp1 = 0 ;
36757 int res1 = 0 ;
36758 PyObject *swig_obj[1] ;
36759
36760 if (!args) SWIG_fail;
36761 swig_obj[0] = args;
36762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36763 if (!SWIG_IsOK(res1)) {
36764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36765 }
36766 arg1 = reinterpret_cast< wxWindow * >(argp1);
36767 {
36768 PyThreadState* __tstate = wxPyBeginAllowThreads();
36769 result = (bool)(arg1)->LineDown();
36770 wxPyEndAllowThreads(__tstate);
36771 if (PyErr_Occurred()) SWIG_fail;
36772 }
36773 {
36774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36775 }
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36783 PyObject *resultobj = 0;
36784 wxWindow *arg1 = (wxWindow *) 0 ;
36785 bool result;
36786 void *argp1 = 0 ;
36787 int res1 = 0 ;
36788 PyObject *swig_obj[1] ;
36789
36790 if (!args) SWIG_fail;
36791 swig_obj[0] = args;
36792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36793 if (!SWIG_IsOK(res1)) {
36794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36795 }
36796 arg1 = reinterpret_cast< wxWindow * >(argp1);
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = (bool)(arg1)->PageUp();
36800 wxPyEndAllowThreads(__tstate);
36801 if (PyErr_Occurred()) SWIG_fail;
36802 }
36803 {
36804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36805 }
36806 return resultobj;
36807 fail:
36808 return NULL;
36809 }
36810
36811
36812 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36813 PyObject *resultobj = 0;
36814 wxWindow *arg1 = (wxWindow *) 0 ;
36815 bool result;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 PyObject *swig_obj[1] ;
36819
36820 if (!args) SWIG_fail;
36821 swig_obj[0] = args;
36822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36823 if (!SWIG_IsOK(res1)) {
36824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36825 }
36826 arg1 = reinterpret_cast< wxWindow * >(argp1);
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 result = (bool)(arg1)->PageDown();
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 {
36834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36835 }
36836 return resultobj;
36837 fail:
36838 return NULL;
36839 }
36840
36841
36842 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36843 PyObject *resultobj = 0;
36844 wxWindow *arg1 = (wxWindow *) 0 ;
36845 wxString *arg2 = 0 ;
36846 void *argp1 = 0 ;
36847 int res1 = 0 ;
36848 bool temp2 = false ;
36849 PyObject * obj0 = 0 ;
36850 PyObject * obj1 = 0 ;
36851 char * kwnames[] = {
36852 (char *) "self",(char *) "text", NULL
36853 };
36854
36855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36857 if (!SWIG_IsOK(res1)) {
36858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36859 }
36860 arg1 = reinterpret_cast< wxWindow * >(argp1);
36861 {
36862 arg2 = wxString_in_helper(obj1);
36863 if (arg2 == NULL) SWIG_fail;
36864 temp2 = true;
36865 }
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 (arg1)->SetHelpText((wxString const &)*arg2);
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 resultobj = SWIG_Py_Void();
36873 {
36874 if (temp2)
36875 delete arg2;
36876 }
36877 return resultobj;
36878 fail:
36879 {
36880 if (temp2)
36881 delete arg2;
36882 }
36883 return NULL;
36884 }
36885
36886
36887 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36888 PyObject *resultobj = 0;
36889 wxWindow *arg1 = (wxWindow *) 0 ;
36890 wxString *arg2 = 0 ;
36891 void *argp1 = 0 ;
36892 int res1 = 0 ;
36893 bool temp2 = false ;
36894 PyObject * obj0 = 0 ;
36895 PyObject * obj1 = 0 ;
36896 char * kwnames[] = {
36897 (char *) "self",(char *) "text", NULL
36898 };
36899
36900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36902 if (!SWIG_IsOK(res1)) {
36903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36904 }
36905 arg1 = reinterpret_cast< wxWindow * >(argp1);
36906 {
36907 arg2 = wxString_in_helper(obj1);
36908 if (arg2 == NULL) SWIG_fail;
36909 temp2 = true;
36910 }
36911 {
36912 PyThreadState* __tstate = wxPyBeginAllowThreads();
36913 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36914 wxPyEndAllowThreads(__tstate);
36915 if (PyErr_Occurred()) SWIG_fail;
36916 }
36917 resultobj = SWIG_Py_Void();
36918 {
36919 if (temp2)
36920 delete arg2;
36921 }
36922 return resultobj;
36923 fail:
36924 {
36925 if (temp2)
36926 delete arg2;
36927 }
36928 return NULL;
36929 }
36930
36931
36932 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36933 PyObject *resultobj = 0;
36934 wxWindow *arg1 = (wxWindow *) 0 ;
36935 wxPoint *arg2 = 0 ;
36936 wxHelpEvent::Origin arg3 ;
36937 wxString result;
36938 void *argp1 = 0 ;
36939 int res1 = 0 ;
36940 wxPoint temp2 ;
36941 void *argp3 ;
36942 int res3 = 0 ;
36943 PyObject * obj0 = 0 ;
36944 PyObject * obj1 = 0 ;
36945 PyObject * obj2 = 0 ;
36946 char * kwnames[] = {
36947 (char *) "self",(char *) "pt",(char *) "origin", NULL
36948 };
36949
36950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36954 }
36955 arg1 = reinterpret_cast< wxWindow * >(argp1);
36956 {
36957 arg2 = &temp2;
36958 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36959 }
36960 {
36961 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36962 if (!SWIG_IsOK(res3)) {
36963 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36964 }
36965 if (!argp3) {
36966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36967 } else {
36968 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36969 arg3 = *temp;
36970 if (SWIG_IsNewObj(res3)) delete temp;
36971 }
36972 }
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
36976 wxPyEndAllowThreads(__tstate);
36977 if (PyErr_Occurred()) SWIG_fail;
36978 }
36979 {
36980 #if wxUSE_UNICODE
36981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36982 #else
36983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36984 #endif
36985 }
36986 return resultobj;
36987 fail:
36988 return NULL;
36989 }
36990
36991
36992 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36993 PyObject *resultobj = 0;
36994 wxWindow *arg1 = (wxWindow *) 0 ;
36995 wxString result;
36996 void *argp1 = 0 ;
36997 int res1 = 0 ;
36998 PyObject *swig_obj[1] ;
36999
37000 if (!args) SWIG_fail;
37001 swig_obj[0] = args;
37002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37005 }
37006 arg1 = reinterpret_cast< wxWindow * >(argp1);
37007 {
37008 PyThreadState* __tstate = wxPyBeginAllowThreads();
37009 result = ((wxWindow const *)arg1)->GetHelpText();
37010 wxPyEndAllowThreads(__tstate);
37011 if (PyErr_Occurred()) SWIG_fail;
37012 }
37013 {
37014 #if wxUSE_UNICODE
37015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37016 #else
37017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37018 #endif
37019 }
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37027 PyObject *resultobj = 0;
37028 wxWindow *arg1 = (wxWindow *) 0 ;
37029 wxString *arg2 = 0 ;
37030 void *argp1 = 0 ;
37031 int res1 = 0 ;
37032 bool temp2 = false ;
37033 PyObject * obj0 = 0 ;
37034 PyObject * obj1 = 0 ;
37035 char * kwnames[] = {
37036 (char *) "self",(char *) "tip", NULL
37037 };
37038
37039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37041 if (!SWIG_IsOK(res1)) {
37042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37043 }
37044 arg1 = reinterpret_cast< wxWindow * >(argp1);
37045 {
37046 arg2 = wxString_in_helper(obj1);
37047 if (arg2 == NULL) SWIG_fail;
37048 temp2 = true;
37049 }
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 (arg1)->SetToolTip((wxString const &)*arg2);
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 resultobj = SWIG_Py_Void();
37057 {
37058 if (temp2)
37059 delete arg2;
37060 }
37061 return resultobj;
37062 fail:
37063 {
37064 if (temp2)
37065 delete arg2;
37066 }
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37072 PyObject *resultobj = 0;
37073 wxWindow *arg1 = (wxWindow *) 0 ;
37074 wxToolTip *arg2 = (wxToolTip *) 0 ;
37075 void *argp1 = 0 ;
37076 int res1 = 0 ;
37077 int res2 = 0 ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 char * kwnames[] = {
37081 (char *) "self",(char *) "tip", NULL
37082 };
37083
37084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37091 if (!SWIG_IsOK(res2)) {
37092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 (arg1)->SetToolTip(arg2);
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 resultobj = SWIG_Py_Void();
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37108 PyObject *resultobj = 0;
37109 wxWindow *arg1 = (wxWindow *) 0 ;
37110 wxToolTip *result = 0 ;
37111 void *argp1 = 0 ;
37112 int res1 = 0 ;
37113 PyObject *swig_obj[1] ;
37114
37115 if (!args) SWIG_fail;
37116 swig_obj[0] = args;
37117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37118 if (!SWIG_IsOK(res1)) {
37119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37120 }
37121 arg1 = reinterpret_cast< wxWindow * >(argp1);
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 {
37129 resultobj = wxPyMake_wxObject(result, (bool)0);
37130 }
37131 return resultobj;
37132 fail:
37133 return NULL;
37134 }
37135
37136
37137 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37138 PyObject *resultobj = 0;
37139 wxWindow *arg1 = (wxWindow *) 0 ;
37140 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37141 void *argp1 = 0 ;
37142 int res1 = 0 ;
37143 int res2 = 0 ;
37144 PyObject * obj0 = 0 ;
37145 PyObject * obj1 = 0 ;
37146 char * kwnames[] = {
37147 (char *) "self",(char *) "dropTarget", NULL
37148 };
37149
37150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37154 }
37155 arg1 = reinterpret_cast< wxWindow * >(argp1);
37156 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37157 if (!SWIG_IsOK(res2)) {
37158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37159 }
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 (arg1)->SetDropTarget(arg2);
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 resultobj = SWIG_Py_Void();
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37174 PyObject *resultobj = 0;
37175 wxWindow *arg1 = (wxWindow *) 0 ;
37176 wxPyDropTarget *result = 0 ;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 PyObject *swig_obj[1] ;
37180
37181 if (!args) SWIG_fail;
37182 swig_obj[0] = args;
37183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37186 }
37187 arg1 = reinterpret_cast< wxWindow * >(argp1);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 bool arg2 ;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207 bool val2 ;
37208 int ecode2 = 0 ;
37209 PyObject * obj0 = 0 ;
37210 PyObject * obj1 = 0 ;
37211 char * kwnames[] = {
37212 (char *) "self",(char *) "accept", NULL
37213 };
37214
37215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37217 if (!SWIG_IsOK(res1)) {
37218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37219 }
37220 arg1 = reinterpret_cast< wxWindow * >(argp1);
37221 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37222 if (!SWIG_IsOK(ecode2)) {
37223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37224 }
37225 arg2 = static_cast< bool >(val2);
37226 {
37227 PyThreadState* __tstate = wxPyBeginAllowThreads();
37228 wxWindow_DragAcceptFiles(arg1,arg2);
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 resultobj = SWIG_Py_Void();
37233 return resultobj;
37234 fail:
37235 return NULL;
37236 }
37237
37238
37239 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37240 PyObject *resultobj = 0;
37241 wxWindow *arg1 = (wxWindow *) 0 ;
37242 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37243 void *argp1 = 0 ;
37244 int res1 = 0 ;
37245 int res2 = 0 ;
37246 PyObject * obj0 = 0 ;
37247 PyObject * obj1 = 0 ;
37248 char * kwnames[] = {
37249 (char *) "self",(char *) "constraints", NULL
37250 };
37251
37252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37254 if (!SWIG_IsOK(res1)) {
37255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37256 }
37257 arg1 = reinterpret_cast< wxWindow * >(argp1);
37258 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37259 if (!SWIG_IsOK(res2)) {
37260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37261 }
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 (arg1)->SetConstraints(arg2);
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 resultobj = SWIG_Py_Void();
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37276 PyObject *resultobj = 0;
37277 wxWindow *arg1 = (wxWindow *) 0 ;
37278 wxLayoutConstraints *result = 0 ;
37279 void *argp1 = 0 ;
37280 int res1 = 0 ;
37281 PyObject *swig_obj[1] ;
37282
37283 if (!args) SWIG_fail;
37284 swig_obj[0] = args;
37285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37288 }
37289 arg1 = reinterpret_cast< wxWindow * >(argp1);
37290 {
37291 PyThreadState* __tstate = wxPyBeginAllowThreads();
37292 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37304 PyObject *resultobj = 0;
37305 wxWindow *arg1 = (wxWindow *) 0 ;
37306 bool arg2 ;
37307 void *argp1 = 0 ;
37308 int res1 = 0 ;
37309 bool val2 ;
37310 int ecode2 = 0 ;
37311 PyObject * obj0 = 0 ;
37312 PyObject * obj1 = 0 ;
37313 char * kwnames[] = {
37314 (char *) "self",(char *) "autoLayout", NULL
37315 };
37316
37317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37319 if (!SWIG_IsOK(res1)) {
37320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37321 }
37322 arg1 = reinterpret_cast< wxWindow * >(argp1);
37323 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37324 if (!SWIG_IsOK(ecode2)) {
37325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37326 }
37327 arg2 = static_cast< bool >(val2);
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 (arg1)->SetAutoLayout(arg2);
37331 wxPyEndAllowThreads(__tstate);
37332 if (PyErr_Occurred()) SWIG_fail;
37333 }
37334 resultobj = SWIG_Py_Void();
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37342 PyObject *resultobj = 0;
37343 wxWindow *arg1 = (wxWindow *) 0 ;
37344 bool result;
37345 void *argp1 = 0 ;
37346 int res1 = 0 ;
37347 PyObject *swig_obj[1] ;
37348
37349 if (!args) SWIG_fail;
37350 swig_obj[0] = args;
37351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 {
37363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37364 }
37365 return resultobj;
37366 fail:
37367 return NULL;
37368 }
37369
37370
37371 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37372 PyObject *resultobj = 0;
37373 wxWindow *arg1 = (wxWindow *) 0 ;
37374 bool result;
37375 void *argp1 = 0 ;
37376 int res1 = 0 ;
37377 PyObject *swig_obj[1] ;
37378
37379 if (!args) SWIG_fail;
37380 swig_obj[0] = args;
37381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37382 if (!SWIG_IsOK(res1)) {
37383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37384 }
37385 arg1 = reinterpret_cast< wxWindow * >(argp1);
37386 {
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 result = (bool)(arg1)->Layout();
37389 wxPyEndAllowThreads(__tstate);
37390 if (PyErr_Occurred()) SWIG_fail;
37391 }
37392 {
37393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37394 }
37395 return resultobj;
37396 fail:
37397 return NULL;
37398 }
37399
37400
37401 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37402 PyObject *resultobj = 0;
37403 wxWindow *arg1 = (wxWindow *) 0 ;
37404 wxSizer *arg2 = (wxSizer *) 0 ;
37405 bool arg3 = (bool) true ;
37406 void *argp1 = 0 ;
37407 int res1 = 0 ;
37408 int res2 = 0 ;
37409 bool val3 ;
37410 int ecode3 = 0 ;
37411 PyObject * obj0 = 0 ;
37412 PyObject * obj1 = 0 ;
37413 PyObject * obj2 = 0 ;
37414 char * kwnames[] = {
37415 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37416 };
37417
37418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) 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_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37422 }
37423 arg1 = reinterpret_cast< wxWindow * >(argp1);
37424 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37425 if (!SWIG_IsOK(res2)) {
37426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37427 }
37428 if (obj2) {
37429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37430 if (!SWIG_IsOK(ecode3)) {
37431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37432 }
37433 arg3 = static_cast< bool >(val3);
37434 }
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 (arg1)->SetSizer(arg2,arg3);
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 resultobj = SWIG_Py_Void();
37442 return resultobj;
37443 fail:
37444 return NULL;
37445 }
37446
37447
37448 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37449 PyObject *resultobj = 0;
37450 wxWindow *arg1 = (wxWindow *) 0 ;
37451 wxSizer *arg2 = (wxSizer *) 0 ;
37452 bool arg3 = (bool) true ;
37453 void *argp1 = 0 ;
37454 int res1 = 0 ;
37455 int res2 = 0 ;
37456 bool val3 ;
37457 int ecode3 = 0 ;
37458 PyObject * obj0 = 0 ;
37459 PyObject * obj1 = 0 ;
37460 PyObject * obj2 = 0 ;
37461 char * kwnames[] = {
37462 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37463 };
37464
37465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37467 if (!SWIG_IsOK(res1)) {
37468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37469 }
37470 arg1 = reinterpret_cast< wxWindow * >(argp1);
37471 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37472 if (!SWIG_IsOK(res2)) {
37473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37474 }
37475 if (obj2) {
37476 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37477 if (!SWIG_IsOK(ecode3)) {
37478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37479 }
37480 arg3 = static_cast< bool >(val3);
37481 }
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 (arg1)->SetSizerAndFit(arg2,arg3);
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 resultobj = SWIG_Py_Void();
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 PyObject *resultobj = 0;
37497 wxWindow *arg1 = (wxWindow *) 0 ;
37498 wxSizer *result = 0 ;
37499 void *argp1 = 0 ;
37500 int res1 = 0 ;
37501 PyObject *swig_obj[1] ;
37502
37503 if (!args) SWIG_fail;
37504 swig_obj[0] = args;
37505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 {
37517 resultobj = wxPyMake_wxObject(result, (bool)0);
37518 }
37519 return resultobj;
37520 fail:
37521 return NULL;
37522 }
37523
37524
37525 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37526 PyObject *resultobj = 0;
37527 wxWindow *arg1 = (wxWindow *) 0 ;
37528 wxSizer *arg2 = (wxSizer *) 0 ;
37529 void *argp1 = 0 ;
37530 int res1 = 0 ;
37531 void *argp2 = 0 ;
37532 int res2 = 0 ;
37533 PyObject * obj0 = 0 ;
37534 PyObject * obj1 = 0 ;
37535 char * kwnames[] = {
37536 (char *) "self",(char *) "sizer", NULL
37537 };
37538
37539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37541 if (!SWIG_IsOK(res1)) {
37542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37543 }
37544 arg1 = reinterpret_cast< wxWindow * >(argp1);
37545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37546 if (!SWIG_IsOK(res2)) {
37547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37548 }
37549 arg2 = reinterpret_cast< wxSizer * >(argp2);
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 (arg1)->SetContainingSizer(arg2);
37553 wxPyEndAllowThreads(__tstate);
37554 if (PyErr_Occurred()) SWIG_fail;
37555 }
37556 resultobj = SWIG_Py_Void();
37557 return resultobj;
37558 fail:
37559 return NULL;
37560 }
37561
37562
37563 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37564 PyObject *resultobj = 0;
37565 wxWindow *arg1 = (wxWindow *) 0 ;
37566 wxSizer *result = 0 ;
37567 void *argp1 = 0 ;
37568 int res1 = 0 ;
37569 PyObject *swig_obj[1] ;
37570
37571 if (!args) SWIG_fail;
37572 swig_obj[0] = args;
37573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37574 if (!SWIG_IsOK(res1)) {
37575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37576 }
37577 arg1 = reinterpret_cast< wxWindow * >(argp1);
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 {
37585 resultobj = wxPyMake_wxObject(result, (bool)0);
37586 }
37587 return resultobj;
37588 fail:
37589 return NULL;
37590 }
37591
37592
37593 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37594 PyObject *resultobj = 0;
37595 wxWindow *arg1 = (wxWindow *) 0 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 PyObject *swig_obj[1] ;
37599
37600 if (!args) SWIG_fail;
37601 swig_obj[0] = args;
37602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37605 }
37606 arg1 = reinterpret_cast< wxWindow * >(argp1);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 (arg1)->InheritAttributes();
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 resultobj = SWIG_Py_Void();
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 bool result;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 PyObject *swig_obj[1] ;
37627
37628 if (!args) SWIG_fail;
37629 swig_obj[0] = args;
37630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37631 if (!SWIG_IsOK(res1)) {
37632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37633 }
37634 arg1 = reinterpret_cast< wxWindow * >(argp1);
37635 {
37636 PyThreadState* __tstate = wxPyBeginAllowThreads();
37637 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37638 wxPyEndAllowThreads(__tstate);
37639 if (PyErr_Occurred()) SWIG_fail;
37640 }
37641 {
37642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37643 }
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37651 PyObject *obj;
37652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37653 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37654 return SWIG_Py_Void();
37655 }
37656
37657 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37658 return SWIG_Python_InitShadowInstance(args);
37659 }
37660
37661 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37662 PyObject *resultobj = 0;
37663 long arg1 ;
37664 wxWindow *arg2 = (wxWindow *) NULL ;
37665 wxWindow *result = 0 ;
37666 long val1 ;
37667 int ecode1 = 0 ;
37668 void *argp2 = 0 ;
37669 int res2 = 0 ;
37670 PyObject * obj0 = 0 ;
37671 PyObject * obj1 = 0 ;
37672 char * kwnames[] = {
37673 (char *) "id",(char *) "parent", NULL
37674 };
37675
37676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37677 ecode1 = SWIG_AsVal_long(obj0, &val1);
37678 if (!SWIG_IsOK(ecode1)) {
37679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37680 }
37681 arg1 = static_cast< long >(val1);
37682 if (obj1) {
37683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37684 if (!SWIG_IsOK(res2)) {
37685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37686 }
37687 arg2 = reinterpret_cast< wxWindow * >(argp2);
37688 }
37689 {
37690 if (!wxPyCheckForApp()) SWIG_fail;
37691 PyThreadState* __tstate = wxPyBeginAllowThreads();
37692 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37693 wxPyEndAllowThreads(__tstate);
37694 if (PyErr_Occurred()) SWIG_fail;
37695 }
37696 {
37697 resultobj = wxPyMake_wxObject(result, 0);
37698 }
37699 return resultobj;
37700 fail:
37701 return NULL;
37702 }
37703
37704
37705 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = 0;
37707 wxString *arg1 = 0 ;
37708 wxWindow *arg2 = (wxWindow *) NULL ;
37709 wxWindow *result = 0 ;
37710 bool temp1 = false ;
37711 void *argp2 = 0 ;
37712 int res2 = 0 ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "name",(char *) "parent", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37720 {
37721 arg1 = wxString_in_helper(obj0);
37722 if (arg1 == NULL) SWIG_fail;
37723 temp1 = true;
37724 }
37725 if (obj1) {
37726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37727 if (!SWIG_IsOK(res2)) {
37728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37729 }
37730 arg2 = reinterpret_cast< wxWindow * >(argp2);
37731 }
37732 {
37733 if (!wxPyCheckForApp()) SWIG_fail;
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37736 wxPyEndAllowThreads(__tstate);
37737 if (PyErr_Occurred()) SWIG_fail;
37738 }
37739 {
37740 resultobj = wxPyMake_wxObject(result, 0);
37741 }
37742 {
37743 if (temp1)
37744 delete arg1;
37745 }
37746 return resultobj;
37747 fail:
37748 {
37749 if (temp1)
37750 delete arg1;
37751 }
37752 return NULL;
37753 }
37754
37755
37756 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37757 PyObject *resultobj = 0;
37758 wxString *arg1 = 0 ;
37759 wxWindow *arg2 = (wxWindow *) NULL ;
37760 wxWindow *result = 0 ;
37761 bool temp1 = false ;
37762 void *argp2 = 0 ;
37763 int res2 = 0 ;
37764 PyObject * obj0 = 0 ;
37765 PyObject * obj1 = 0 ;
37766 char * kwnames[] = {
37767 (char *) "label",(char *) "parent", NULL
37768 };
37769
37770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37771 {
37772 arg1 = wxString_in_helper(obj0);
37773 if (arg1 == NULL) SWIG_fail;
37774 temp1 = true;
37775 }
37776 if (obj1) {
37777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37778 if (!SWIG_IsOK(res2)) {
37779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37780 }
37781 arg2 = reinterpret_cast< wxWindow * >(argp2);
37782 }
37783 {
37784 if (!wxPyCheckForApp()) SWIG_fail;
37785 PyThreadState* __tstate = wxPyBeginAllowThreads();
37786 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 {
37791 resultobj = wxPyMake_wxObject(result, 0);
37792 }
37793 {
37794 if (temp1)
37795 delete arg1;
37796 }
37797 return resultobj;
37798 fail:
37799 {
37800 if (temp1)
37801 delete arg1;
37802 }
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37808 PyObject *resultobj = 0;
37809 wxWindow *arg1 = (wxWindow *) 0 ;
37810 unsigned long arg2 ;
37811 wxWindow *result = 0 ;
37812 void *argp1 = 0 ;
37813 int res1 = 0 ;
37814 unsigned long val2 ;
37815 int ecode2 = 0 ;
37816 PyObject * obj0 = 0 ;
37817 PyObject * obj1 = 0 ;
37818 char * kwnames[] = {
37819 (char *) "parent",(char *) "_hWnd", NULL
37820 };
37821
37822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37824 if (!SWIG_IsOK(res1)) {
37825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37826 }
37827 arg1 = reinterpret_cast< wxWindow * >(argp1);
37828 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37829 if (!SWIG_IsOK(ecode2)) {
37830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37831 }
37832 arg2 = static_cast< unsigned long >(val2);
37833 {
37834 PyThreadState* __tstate = wxPyBeginAllowThreads();
37835 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37836 wxPyEndAllowThreads(__tstate);
37837 if (PyErr_Occurred()) SWIG_fail;
37838 }
37839 {
37840 resultobj = wxPyMake_wxObject(result, 0);
37841 }
37842 return resultobj;
37843 fail:
37844 return NULL;
37845 }
37846
37847
37848 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37849 PyObject *resultobj = 0;
37850 PyObject *result = 0 ;
37851
37852 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37853 {
37854 PyThreadState* __tstate = wxPyBeginAllowThreads();
37855 result = (PyObject *)GetTopLevelWindows();
37856 wxPyEndAllowThreads(__tstate);
37857 if (PyErr_Occurred()) SWIG_fail;
37858 }
37859 resultobj = result;
37860 return resultobj;
37861 fail:
37862 return NULL;
37863 }
37864
37865
37866 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37867 PyObject *resultobj = 0;
37868 wxValidator *result = 0 ;
37869
37870 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37871 {
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 result = (wxValidator *)new wxValidator();
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37885 PyObject *resultobj = 0;
37886 wxValidator *arg1 = (wxValidator *) 0 ;
37887 wxValidator *result = 0 ;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 PyObject *swig_obj[1] ;
37891
37892 if (!args) SWIG_fail;
37893 swig_obj[0] = args;
37894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37895 if (!SWIG_IsOK(res1)) {
37896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37897 }
37898 arg1 = reinterpret_cast< wxValidator * >(argp1);
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (wxValidator *)(arg1)->Clone();
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 {
37906 resultobj = wxPyMake_wxObject(result, 0);
37907 }
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37915 PyObject *resultobj = 0;
37916 wxValidator *arg1 = (wxValidator *) 0 ;
37917 wxWindow *arg2 = (wxWindow *) 0 ;
37918 bool result;
37919 void *argp1 = 0 ;
37920 int res1 = 0 ;
37921 void *argp2 = 0 ;
37922 int res2 = 0 ;
37923 PyObject * obj0 = 0 ;
37924 PyObject * obj1 = 0 ;
37925 char * kwnames[] = {
37926 (char *) "self",(char *) "parent", NULL
37927 };
37928
37929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37931 if (!SWIG_IsOK(res1)) {
37932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37933 }
37934 arg1 = reinterpret_cast< wxValidator * >(argp1);
37935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37936 if (!SWIG_IsOK(res2)) {
37937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37938 }
37939 arg2 = reinterpret_cast< wxWindow * >(argp2);
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (bool)(arg1)->Validate(arg2);
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 {
37947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37948 }
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37956 PyObject *resultobj = 0;
37957 wxValidator *arg1 = (wxValidator *) 0 ;
37958 bool result;
37959 void *argp1 = 0 ;
37960 int res1 = 0 ;
37961 PyObject *swig_obj[1] ;
37962
37963 if (!args) SWIG_fail;
37964 swig_obj[0] = args;
37965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37966 if (!SWIG_IsOK(res1)) {
37967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37968 }
37969 arg1 = reinterpret_cast< wxValidator * >(argp1);
37970 {
37971 PyThreadState* __tstate = wxPyBeginAllowThreads();
37972 result = (bool)(arg1)->TransferToWindow();
37973 wxPyEndAllowThreads(__tstate);
37974 if (PyErr_Occurred()) SWIG_fail;
37975 }
37976 {
37977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37978 }
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37986 PyObject *resultobj = 0;
37987 wxValidator *arg1 = (wxValidator *) 0 ;
37988 bool result;
37989 void *argp1 = 0 ;
37990 int res1 = 0 ;
37991 PyObject *swig_obj[1] ;
37992
37993 if (!args) SWIG_fail;
37994 swig_obj[0] = args;
37995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37998 }
37999 arg1 = reinterpret_cast< wxValidator * >(argp1);
38000 {
38001 PyThreadState* __tstate = wxPyBeginAllowThreads();
38002 result = (bool)(arg1)->TransferFromWindow();
38003 wxPyEndAllowThreads(__tstate);
38004 if (PyErr_Occurred()) SWIG_fail;
38005 }
38006 {
38007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38008 }
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38016 PyObject *resultobj = 0;
38017 wxValidator *arg1 = (wxValidator *) 0 ;
38018 wxWindow *result = 0 ;
38019 void *argp1 = 0 ;
38020 int res1 = 0 ;
38021 PyObject *swig_obj[1] ;
38022
38023 if (!args) SWIG_fail;
38024 swig_obj[0] = args;
38025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38026 if (!SWIG_IsOK(res1)) {
38027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38028 }
38029 arg1 = reinterpret_cast< wxValidator * >(argp1);
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (wxWindow *)(arg1)->GetWindow();
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = wxPyMake_wxObject(result, 0);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj = 0;
38047 wxValidator *arg1 = (wxValidator *) 0 ;
38048 wxWindow *arg2 = (wxWindow *) 0 ;
38049 void *argp1 = 0 ;
38050 int res1 = 0 ;
38051 void *argp2 = 0 ;
38052 int res2 = 0 ;
38053 PyObject * obj0 = 0 ;
38054 PyObject * obj1 = 0 ;
38055 char * kwnames[] = {
38056 (char *) "self",(char *) "window", NULL
38057 };
38058
38059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38063 }
38064 arg1 = reinterpret_cast< wxValidator * >(argp1);
38065 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38066 if (!SWIG_IsOK(res2)) {
38067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38068 }
38069 arg2 = reinterpret_cast< wxWindow * >(argp2);
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 (arg1)->SetWindow(arg2);
38073 wxPyEndAllowThreads(__tstate);
38074 if (PyErr_Occurred()) SWIG_fail;
38075 }
38076 resultobj = SWIG_Py_Void();
38077 return resultobj;
38078 fail:
38079 return NULL;
38080 }
38081
38082
38083 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38084 PyObject *resultobj = 0;
38085 bool result;
38086
38087 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38088 {
38089 PyThreadState* __tstate = wxPyBeginAllowThreads();
38090 result = (bool)wxValidator::IsSilent();
38091 wxPyEndAllowThreads(__tstate);
38092 if (PyErr_Occurred()) SWIG_fail;
38093 }
38094 {
38095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38096 }
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj = 0;
38105 int arg1 = (int) true ;
38106 int val1 ;
38107 int ecode1 = 0 ;
38108 PyObject * obj0 = 0 ;
38109 char * kwnames[] = {
38110 (char *) "doIt", NULL
38111 };
38112
38113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38114 if (obj0) {
38115 ecode1 = SWIG_AsVal_int(obj0, &val1);
38116 if (!SWIG_IsOK(ecode1)) {
38117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38118 }
38119 arg1 = static_cast< int >(val1);
38120 }
38121 {
38122 PyThreadState* __tstate = wxPyBeginAllowThreads();
38123 wxValidator::SetBellOnError(arg1);
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 resultobj = SWIG_Py_Void();
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38135 PyObject *obj;
38136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38137 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38138 return SWIG_Py_Void();
38139 }
38140
38141 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38142 return SWIG_Python_InitShadowInstance(args);
38143 }
38144
38145 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38146 PyObject *resultobj = 0;
38147 wxPyValidator *result = 0 ;
38148
38149 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38150 {
38151 PyThreadState* __tstate = wxPyBeginAllowThreads();
38152 result = (wxPyValidator *)new wxPyValidator();
38153 wxPyEndAllowThreads(__tstate);
38154 if (PyErr_Occurred()) SWIG_fail;
38155 }
38156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38157 return resultobj;
38158 fail:
38159 return NULL;
38160 }
38161
38162
38163 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38164 PyObject *resultobj = 0;
38165 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38166 PyObject *arg2 = (PyObject *) 0 ;
38167 PyObject *arg3 = (PyObject *) 0 ;
38168 int arg4 = (int) true ;
38169 void *argp1 = 0 ;
38170 int res1 = 0 ;
38171 int val4 ;
38172 int ecode4 = 0 ;
38173 PyObject * obj0 = 0 ;
38174 PyObject * obj1 = 0 ;
38175 PyObject * obj2 = 0 ;
38176 PyObject * obj3 = 0 ;
38177 char * kwnames[] = {
38178 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38179 };
38180
38181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38183 if (!SWIG_IsOK(res1)) {
38184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38185 }
38186 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38187 arg2 = obj1;
38188 arg3 = obj2;
38189 if (obj3) {
38190 ecode4 = SWIG_AsVal_int(obj3, &val4);
38191 if (!SWIG_IsOK(ecode4)) {
38192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38193 }
38194 arg4 = static_cast< int >(val4);
38195 }
38196 {
38197 PyThreadState* __tstate = wxPyBeginAllowThreads();
38198 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38199 wxPyEndAllowThreads(__tstate);
38200 if (PyErr_Occurred()) SWIG_fail;
38201 }
38202 resultobj = SWIG_Py_Void();
38203 return resultobj;
38204 fail:
38205 return NULL;
38206 }
38207
38208
38209 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38210 PyObject *obj;
38211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38212 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38213 return SWIG_Py_Void();
38214 }
38215
38216 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38217 return SWIG_Python_InitShadowInstance(args);
38218 }
38219
38220 SWIGINTERN int DefaultValidator_set(PyObject *) {
38221 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38222 return 1;
38223 }
38224
38225
38226 SWIGINTERN PyObject *DefaultValidator_get(void) {
38227 PyObject *pyobj = 0;
38228
38229 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38230 return pyobj;
38231 }
38232
38233
38234 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38235 PyObject *resultobj = 0;
38236 wxString const &arg1_defvalue = wxPyEmptyString ;
38237 wxString *arg1 = (wxString *) &arg1_defvalue ;
38238 long arg2 = (long) 0 ;
38239 wxMenu *result = 0 ;
38240 bool temp1 = false ;
38241 long val2 ;
38242 int ecode2 = 0 ;
38243 PyObject * obj0 = 0 ;
38244 PyObject * obj1 = 0 ;
38245 char * kwnames[] = {
38246 (char *) "title",(char *) "style", NULL
38247 };
38248
38249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38250 if (obj0) {
38251 {
38252 arg1 = wxString_in_helper(obj0);
38253 if (arg1 == NULL) SWIG_fail;
38254 temp1 = true;
38255 }
38256 }
38257 if (obj1) {
38258 ecode2 = SWIG_AsVal_long(obj1, &val2);
38259 if (!SWIG_IsOK(ecode2)) {
38260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38261 }
38262 arg2 = static_cast< long >(val2);
38263 }
38264 {
38265 if (!wxPyCheckForApp()) SWIG_fail;
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38272 {
38273 if (temp1)
38274 delete arg1;
38275 }
38276 return resultobj;
38277 fail:
38278 {
38279 if (temp1)
38280 delete arg1;
38281 }
38282 return NULL;
38283 }
38284
38285
38286 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38287 PyObject *resultobj = 0;
38288 wxMenu *arg1 = (wxMenu *) 0 ;
38289 int arg2 ;
38290 wxString *arg3 = 0 ;
38291 wxString const &arg4_defvalue = wxPyEmptyString ;
38292 wxString *arg4 = (wxString *) &arg4_defvalue ;
38293 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38294 wxMenuItem *result = 0 ;
38295 void *argp1 = 0 ;
38296 int res1 = 0 ;
38297 int val2 ;
38298 int ecode2 = 0 ;
38299 bool temp3 = false ;
38300 bool temp4 = false ;
38301 int val5 ;
38302 int ecode5 = 0 ;
38303 PyObject * obj0 = 0 ;
38304 PyObject * obj1 = 0 ;
38305 PyObject * obj2 = 0 ;
38306 PyObject * obj3 = 0 ;
38307 PyObject * obj4 = 0 ;
38308 char * kwnames[] = {
38309 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38310 };
38311
38312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38314 if (!SWIG_IsOK(res1)) {
38315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38316 }
38317 arg1 = reinterpret_cast< wxMenu * >(argp1);
38318 ecode2 = SWIG_AsVal_int(obj1, &val2);
38319 if (!SWIG_IsOK(ecode2)) {
38320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38321 }
38322 arg2 = static_cast< int >(val2);
38323 {
38324 arg3 = wxString_in_helper(obj2);
38325 if (arg3 == NULL) SWIG_fail;
38326 temp3 = true;
38327 }
38328 if (obj3) {
38329 {
38330 arg4 = wxString_in_helper(obj3);
38331 if (arg4 == NULL) SWIG_fail;
38332 temp4 = true;
38333 }
38334 }
38335 if (obj4) {
38336 ecode5 = SWIG_AsVal_int(obj4, &val5);
38337 if (!SWIG_IsOK(ecode5)) {
38338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38339 }
38340 arg5 = static_cast< wxItemKind >(val5);
38341 }
38342 {
38343 PyThreadState* __tstate = wxPyBeginAllowThreads();
38344 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38345 wxPyEndAllowThreads(__tstate);
38346 if (PyErr_Occurred()) SWIG_fail;
38347 }
38348 {
38349 resultobj = wxPyMake_wxObject(result, (bool)0);
38350 }
38351 {
38352 if (temp3)
38353 delete arg3;
38354 }
38355 {
38356 if (temp4)
38357 delete arg4;
38358 }
38359 return resultobj;
38360 fail:
38361 {
38362 if (temp3)
38363 delete arg3;
38364 }
38365 {
38366 if (temp4)
38367 delete arg4;
38368 }
38369 return NULL;
38370 }
38371
38372
38373 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38374 PyObject *resultobj = 0;
38375 wxMenu *arg1 = (wxMenu *) 0 ;
38376 wxMenuItem *result = 0 ;
38377 void *argp1 = 0 ;
38378 int res1 = 0 ;
38379 PyObject *swig_obj[1] ;
38380
38381 if (!args) SWIG_fail;
38382 swig_obj[0] = args;
38383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38384 if (!SWIG_IsOK(res1)) {
38385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38386 }
38387 arg1 = reinterpret_cast< wxMenu * >(argp1);
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (wxMenuItem *)(arg1)->AppendSeparator();
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 resultobj = wxPyMake_wxObject(result, (bool)0);
38396 }
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38404 PyObject *resultobj = 0;
38405 wxMenu *arg1 = (wxMenu *) 0 ;
38406 int arg2 ;
38407 wxString *arg3 = 0 ;
38408 wxString const &arg4_defvalue = wxPyEmptyString ;
38409 wxString *arg4 = (wxString *) &arg4_defvalue ;
38410 wxMenuItem *result = 0 ;
38411 void *argp1 = 0 ;
38412 int res1 = 0 ;
38413 int val2 ;
38414 int ecode2 = 0 ;
38415 bool temp3 = false ;
38416 bool temp4 = false ;
38417 PyObject * obj0 = 0 ;
38418 PyObject * obj1 = 0 ;
38419 PyObject * obj2 = 0 ;
38420 PyObject * obj3 = 0 ;
38421 char * kwnames[] = {
38422 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38423 };
38424
38425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38427 if (!SWIG_IsOK(res1)) {
38428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38429 }
38430 arg1 = reinterpret_cast< wxMenu * >(argp1);
38431 ecode2 = SWIG_AsVal_int(obj1, &val2);
38432 if (!SWIG_IsOK(ecode2)) {
38433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38434 }
38435 arg2 = static_cast< int >(val2);
38436 {
38437 arg3 = wxString_in_helper(obj2);
38438 if (arg3 == NULL) SWIG_fail;
38439 temp3 = true;
38440 }
38441 if (obj3) {
38442 {
38443 arg4 = wxString_in_helper(obj3);
38444 if (arg4 == NULL) SWIG_fail;
38445 temp4 = true;
38446 }
38447 }
38448 {
38449 PyThreadState* __tstate = wxPyBeginAllowThreads();
38450 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38451 wxPyEndAllowThreads(__tstate);
38452 if (PyErr_Occurred()) SWIG_fail;
38453 }
38454 {
38455 resultobj = wxPyMake_wxObject(result, (bool)0);
38456 }
38457 {
38458 if (temp3)
38459 delete arg3;
38460 }
38461 {
38462 if (temp4)
38463 delete arg4;
38464 }
38465 return resultobj;
38466 fail:
38467 {
38468 if (temp3)
38469 delete arg3;
38470 }
38471 {
38472 if (temp4)
38473 delete arg4;
38474 }
38475 return NULL;
38476 }
38477
38478
38479 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj = 0;
38481 wxMenu *arg1 = (wxMenu *) 0 ;
38482 int arg2 ;
38483 wxString *arg3 = 0 ;
38484 wxString const &arg4_defvalue = wxPyEmptyString ;
38485 wxString *arg4 = (wxString *) &arg4_defvalue ;
38486 wxMenuItem *result = 0 ;
38487 void *argp1 = 0 ;
38488 int res1 = 0 ;
38489 int val2 ;
38490 int ecode2 = 0 ;
38491 bool temp3 = false ;
38492 bool temp4 = false ;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 PyObject * obj2 = 0 ;
38496 PyObject * obj3 = 0 ;
38497 char * kwnames[] = {
38498 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38499 };
38500
38501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38503 if (!SWIG_IsOK(res1)) {
38504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38505 }
38506 arg1 = reinterpret_cast< wxMenu * >(argp1);
38507 ecode2 = SWIG_AsVal_int(obj1, &val2);
38508 if (!SWIG_IsOK(ecode2)) {
38509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38510 }
38511 arg2 = static_cast< int >(val2);
38512 {
38513 arg3 = wxString_in_helper(obj2);
38514 if (arg3 == NULL) SWIG_fail;
38515 temp3 = true;
38516 }
38517 if (obj3) {
38518 {
38519 arg4 = wxString_in_helper(obj3);
38520 if (arg4 == NULL) SWIG_fail;
38521 temp4 = true;
38522 }
38523 }
38524 {
38525 PyThreadState* __tstate = wxPyBeginAllowThreads();
38526 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 {
38531 resultobj = wxPyMake_wxObject(result, (bool)0);
38532 }
38533 {
38534 if (temp3)
38535 delete arg3;
38536 }
38537 {
38538 if (temp4)
38539 delete arg4;
38540 }
38541 return resultobj;
38542 fail:
38543 {
38544 if (temp3)
38545 delete arg3;
38546 }
38547 {
38548 if (temp4)
38549 delete arg4;
38550 }
38551 return NULL;
38552 }
38553
38554
38555 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38556 PyObject *resultobj = 0;
38557 wxMenu *arg1 = (wxMenu *) 0 ;
38558 int arg2 ;
38559 wxString *arg3 = 0 ;
38560 wxMenu *arg4 = (wxMenu *) 0 ;
38561 wxString const &arg5_defvalue = wxPyEmptyString ;
38562 wxString *arg5 = (wxString *) &arg5_defvalue ;
38563 wxMenuItem *result = 0 ;
38564 void *argp1 = 0 ;
38565 int res1 = 0 ;
38566 int val2 ;
38567 int ecode2 = 0 ;
38568 bool temp3 = false ;
38569 void *argp4 = 0 ;
38570 int res4 = 0 ;
38571 bool temp5 = false ;
38572 PyObject * obj0 = 0 ;
38573 PyObject * obj1 = 0 ;
38574 PyObject * obj2 = 0 ;
38575 PyObject * obj3 = 0 ;
38576 PyObject * obj4 = 0 ;
38577 char * kwnames[] = {
38578 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38579 };
38580
38581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38583 if (!SWIG_IsOK(res1)) {
38584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38585 }
38586 arg1 = reinterpret_cast< wxMenu * >(argp1);
38587 ecode2 = SWIG_AsVal_int(obj1, &val2);
38588 if (!SWIG_IsOK(ecode2)) {
38589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38590 }
38591 arg2 = static_cast< int >(val2);
38592 {
38593 arg3 = wxString_in_helper(obj2);
38594 if (arg3 == NULL) SWIG_fail;
38595 temp3 = true;
38596 }
38597 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38598 if (!SWIG_IsOK(res4)) {
38599 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38600 }
38601 arg4 = reinterpret_cast< wxMenu * >(argp4);
38602 if (obj4) {
38603 {
38604 arg5 = wxString_in_helper(obj4);
38605 if (arg5 == NULL) SWIG_fail;
38606 temp5 = true;
38607 }
38608 }
38609 {
38610 PyThreadState* __tstate = wxPyBeginAllowThreads();
38611 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38612 wxPyEndAllowThreads(__tstate);
38613 if (PyErr_Occurred()) SWIG_fail;
38614 }
38615 {
38616 resultobj = wxPyMake_wxObject(result, (bool)0);
38617 }
38618 {
38619 if (temp3)
38620 delete arg3;
38621 }
38622 {
38623 if (temp5)
38624 delete arg5;
38625 }
38626 return resultobj;
38627 fail:
38628 {
38629 if (temp3)
38630 delete arg3;
38631 }
38632 {
38633 if (temp5)
38634 delete arg5;
38635 }
38636 return NULL;
38637 }
38638
38639
38640 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj = 0;
38642 wxMenu *arg1 = (wxMenu *) 0 ;
38643 wxMenu *arg2 = (wxMenu *) 0 ;
38644 wxString *arg3 = 0 ;
38645 wxString const &arg4_defvalue = wxPyEmptyString ;
38646 wxString *arg4 = (wxString *) &arg4_defvalue ;
38647 wxMenuItem *result = 0 ;
38648 void *argp1 = 0 ;
38649 int res1 = 0 ;
38650 void *argp2 = 0 ;
38651 int res2 = 0 ;
38652 bool temp3 = false ;
38653 bool temp4 = false ;
38654 PyObject * obj0 = 0 ;
38655 PyObject * obj1 = 0 ;
38656 PyObject * obj2 = 0 ;
38657 PyObject * obj3 = 0 ;
38658 char * kwnames[] = {
38659 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38660 };
38661
38662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38664 if (!SWIG_IsOK(res1)) {
38665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38666 }
38667 arg1 = reinterpret_cast< wxMenu * >(argp1);
38668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38669 if (!SWIG_IsOK(res2)) {
38670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38671 }
38672 arg2 = reinterpret_cast< wxMenu * >(argp2);
38673 {
38674 arg3 = wxString_in_helper(obj2);
38675 if (arg3 == NULL) SWIG_fail;
38676 temp3 = true;
38677 }
38678 if (obj3) {
38679 {
38680 arg4 = wxString_in_helper(obj3);
38681 if (arg4 == NULL) SWIG_fail;
38682 temp4 = true;
38683 }
38684 }
38685 {
38686 PyThreadState* __tstate = wxPyBeginAllowThreads();
38687 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38688 wxPyEndAllowThreads(__tstate);
38689 if (PyErr_Occurred()) SWIG_fail;
38690 }
38691 {
38692 resultobj = wxPyMake_wxObject(result, (bool)0);
38693 }
38694 {
38695 if (temp3)
38696 delete arg3;
38697 }
38698 {
38699 if (temp4)
38700 delete arg4;
38701 }
38702 return resultobj;
38703 fail:
38704 {
38705 if (temp3)
38706 delete arg3;
38707 }
38708 {
38709 if (temp4)
38710 delete arg4;
38711 }
38712 return NULL;
38713 }
38714
38715
38716 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38717 PyObject *resultobj = 0;
38718 wxMenu *arg1 = (wxMenu *) 0 ;
38719 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38720 wxMenuItem *result = 0 ;
38721 void *argp1 = 0 ;
38722 int res1 = 0 ;
38723 int res2 = 0 ;
38724 PyObject * obj0 = 0 ;
38725 PyObject * obj1 = 0 ;
38726 char * kwnames[] = {
38727 (char *) "self",(char *) "item", NULL
38728 };
38729
38730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38732 if (!SWIG_IsOK(res1)) {
38733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38734 }
38735 arg1 = reinterpret_cast< wxMenu * >(argp1);
38736 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38737 if (!SWIG_IsOK(res2)) {
38738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38739 }
38740 {
38741 PyThreadState* __tstate = wxPyBeginAllowThreads();
38742 result = (wxMenuItem *)(arg1)->Append(arg2);
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 {
38747 resultobj = wxPyMake_wxObject(result, (bool)0);
38748 }
38749 return resultobj;
38750 fail:
38751 return NULL;
38752 }
38753
38754
38755 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38756 PyObject *resultobj = 0;
38757 wxMenu *arg1 = (wxMenu *) 0 ;
38758 size_t arg2 ;
38759 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38760 wxMenuItem *result = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 size_t val2 ;
38764 int ecode2 = 0 ;
38765 int res3 = 0 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 PyObject * obj2 = 0 ;
38769 char * kwnames[] = {
38770 (char *) "self",(char *) "pos",(char *) "item", NULL
38771 };
38772
38773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38777 }
38778 arg1 = reinterpret_cast< wxMenu * >(argp1);
38779 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38780 if (!SWIG_IsOK(ecode2)) {
38781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38782 }
38783 arg2 = static_cast< size_t >(val2);
38784 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38785 if (!SWIG_IsOK(res3)) {
38786 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38787 }
38788 {
38789 PyThreadState* __tstate = wxPyBeginAllowThreads();
38790 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 {
38795 resultobj = wxPyMake_wxObject(result, (bool)0);
38796 }
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj = 0;
38805 wxMenu *arg1 = (wxMenu *) 0 ;
38806 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38807 wxMenuItem *result = 0 ;
38808 void *argp1 = 0 ;
38809 int res1 = 0 ;
38810 int res2 = 0 ;
38811 PyObject * obj0 = 0 ;
38812 PyObject * obj1 = 0 ;
38813 char * kwnames[] = {
38814 (char *) "self",(char *) "item", NULL
38815 };
38816
38817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38821 }
38822 arg1 = reinterpret_cast< wxMenu * >(argp1);
38823 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38824 if (!SWIG_IsOK(res2)) {
38825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38826 }
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38830 wxPyEndAllowThreads(__tstate);
38831 if (PyErr_Occurred()) SWIG_fail;
38832 }
38833 {
38834 resultobj = wxPyMake_wxObject(result, (bool)0);
38835 }
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38843 PyObject *resultobj = 0;
38844 wxMenu *arg1 = (wxMenu *) 0 ;
38845 void *argp1 = 0 ;
38846 int res1 = 0 ;
38847 PyObject *swig_obj[1] ;
38848
38849 if (!args) SWIG_fail;
38850 swig_obj[0] = args;
38851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38852 if (!SWIG_IsOK(res1)) {
38853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38854 }
38855 arg1 = reinterpret_cast< wxMenu * >(argp1);
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 (arg1)->Break();
38859 wxPyEndAllowThreads(__tstate);
38860 if (PyErr_Occurred()) SWIG_fail;
38861 }
38862 resultobj = SWIG_Py_Void();
38863 return resultobj;
38864 fail:
38865 return NULL;
38866 }
38867
38868
38869 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38870 PyObject *resultobj = 0;
38871 wxMenu *arg1 = (wxMenu *) 0 ;
38872 size_t arg2 ;
38873 int arg3 ;
38874 wxString *arg4 = 0 ;
38875 wxString const &arg5_defvalue = wxPyEmptyString ;
38876 wxString *arg5 = (wxString *) &arg5_defvalue ;
38877 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38878 wxMenuItem *result = 0 ;
38879 void *argp1 = 0 ;
38880 int res1 = 0 ;
38881 size_t val2 ;
38882 int ecode2 = 0 ;
38883 int val3 ;
38884 int ecode3 = 0 ;
38885 bool temp4 = false ;
38886 bool temp5 = false ;
38887 int val6 ;
38888 int ecode6 = 0 ;
38889 PyObject * obj0 = 0 ;
38890 PyObject * obj1 = 0 ;
38891 PyObject * obj2 = 0 ;
38892 PyObject * obj3 = 0 ;
38893 PyObject * obj4 = 0 ;
38894 PyObject * obj5 = 0 ;
38895 char * kwnames[] = {
38896 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38897 };
38898
38899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38901 if (!SWIG_IsOK(res1)) {
38902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38903 }
38904 arg1 = reinterpret_cast< wxMenu * >(argp1);
38905 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38906 if (!SWIG_IsOK(ecode2)) {
38907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38908 }
38909 arg2 = static_cast< size_t >(val2);
38910 ecode3 = SWIG_AsVal_int(obj2, &val3);
38911 if (!SWIG_IsOK(ecode3)) {
38912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38913 }
38914 arg3 = static_cast< int >(val3);
38915 {
38916 arg4 = wxString_in_helper(obj3);
38917 if (arg4 == NULL) SWIG_fail;
38918 temp4 = true;
38919 }
38920 if (obj4) {
38921 {
38922 arg5 = wxString_in_helper(obj4);
38923 if (arg5 == NULL) SWIG_fail;
38924 temp5 = true;
38925 }
38926 }
38927 if (obj5) {
38928 ecode6 = SWIG_AsVal_int(obj5, &val6);
38929 if (!SWIG_IsOK(ecode6)) {
38930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38931 }
38932 arg6 = static_cast< wxItemKind >(val6);
38933 }
38934 {
38935 PyThreadState* __tstate = wxPyBeginAllowThreads();
38936 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38937 wxPyEndAllowThreads(__tstate);
38938 if (PyErr_Occurred()) SWIG_fail;
38939 }
38940 {
38941 resultobj = wxPyMake_wxObject(result, (bool)0);
38942 }
38943 {
38944 if (temp4)
38945 delete arg4;
38946 }
38947 {
38948 if (temp5)
38949 delete arg5;
38950 }
38951 return resultobj;
38952 fail:
38953 {
38954 if (temp4)
38955 delete arg4;
38956 }
38957 {
38958 if (temp5)
38959 delete arg5;
38960 }
38961 return NULL;
38962 }
38963
38964
38965 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38966 PyObject *resultobj = 0;
38967 wxMenu *arg1 = (wxMenu *) 0 ;
38968 size_t arg2 ;
38969 wxMenuItem *result = 0 ;
38970 void *argp1 = 0 ;
38971 int res1 = 0 ;
38972 size_t val2 ;
38973 int ecode2 = 0 ;
38974 PyObject * obj0 = 0 ;
38975 PyObject * obj1 = 0 ;
38976 char * kwnames[] = {
38977 (char *) "self",(char *) "pos", NULL
38978 };
38979
38980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38982 if (!SWIG_IsOK(res1)) {
38983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38984 }
38985 arg1 = reinterpret_cast< wxMenu * >(argp1);
38986 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38987 if (!SWIG_IsOK(ecode2)) {
38988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38989 }
38990 arg2 = static_cast< size_t >(val2);
38991 {
38992 PyThreadState* __tstate = wxPyBeginAllowThreads();
38993 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 resultobj = wxPyMake_wxObject(result, (bool)0);
38999 }
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj = 0;
39008 wxMenu *arg1 = (wxMenu *) 0 ;
39009 size_t arg2 ;
39010 int arg3 ;
39011 wxString *arg4 = 0 ;
39012 wxString const &arg5_defvalue = wxPyEmptyString ;
39013 wxString *arg5 = (wxString *) &arg5_defvalue ;
39014 wxMenuItem *result = 0 ;
39015 void *argp1 = 0 ;
39016 int res1 = 0 ;
39017 size_t val2 ;
39018 int ecode2 = 0 ;
39019 int val3 ;
39020 int ecode3 = 0 ;
39021 bool temp4 = false ;
39022 bool temp5 = false ;
39023 PyObject * obj0 = 0 ;
39024 PyObject * obj1 = 0 ;
39025 PyObject * obj2 = 0 ;
39026 PyObject * obj3 = 0 ;
39027 PyObject * obj4 = 0 ;
39028 char * kwnames[] = {
39029 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39030 };
39031
39032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39034 if (!SWIG_IsOK(res1)) {
39035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39036 }
39037 arg1 = reinterpret_cast< wxMenu * >(argp1);
39038 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39039 if (!SWIG_IsOK(ecode2)) {
39040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39041 }
39042 arg2 = static_cast< size_t >(val2);
39043 ecode3 = SWIG_AsVal_int(obj2, &val3);
39044 if (!SWIG_IsOK(ecode3)) {
39045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39046 }
39047 arg3 = static_cast< int >(val3);
39048 {
39049 arg4 = wxString_in_helper(obj3);
39050 if (arg4 == NULL) SWIG_fail;
39051 temp4 = true;
39052 }
39053 if (obj4) {
39054 {
39055 arg5 = wxString_in_helper(obj4);
39056 if (arg5 == NULL) SWIG_fail;
39057 temp5 = true;
39058 }
39059 }
39060 {
39061 PyThreadState* __tstate = wxPyBeginAllowThreads();
39062 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 {
39067 resultobj = wxPyMake_wxObject(result, (bool)0);
39068 }
39069 {
39070 if (temp4)
39071 delete arg4;
39072 }
39073 {
39074 if (temp5)
39075 delete arg5;
39076 }
39077 return resultobj;
39078 fail:
39079 {
39080 if (temp4)
39081 delete arg4;
39082 }
39083 {
39084 if (temp5)
39085 delete arg5;
39086 }
39087 return NULL;
39088 }
39089
39090
39091 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39092 PyObject *resultobj = 0;
39093 wxMenu *arg1 = (wxMenu *) 0 ;
39094 size_t arg2 ;
39095 int arg3 ;
39096 wxString *arg4 = 0 ;
39097 wxString const &arg5_defvalue = wxPyEmptyString ;
39098 wxString *arg5 = (wxString *) &arg5_defvalue ;
39099 wxMenuItem *result = 0 ;
39100 void *argp1 = 0 ;
39101 int res1 = 0 ;
39102 size_t val2 ;
39103 int ecode2 = 0 ;
39104 int val3 ;
39105 int ecode3 = 0 ;
39106 bool temp4 = false ;
39107 bool temp5 = false ;
39108 PyObject * obj0 = 0 ;
39109 PyObject * obj1 = 0 ;
39110 PyObject * obj2 = 0 ;
39111 PyObject * obj3 = 0 ;
39112 PyObject * obj4 = 0 ;
39113 char * kwnames[] = {
39114 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39115 };
39116
39117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39119 if (!SWIG_IsOK(res1)) {
39120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39121 }
39122 arg1 = reinterpret_cast< wxMenu * >(argp1);
39123 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39124 if (!SWIG_IsOK(ecode2)) {
39125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39126 }
39127 arg2 = static_cast< size_t >(val2);
39128 ecode3 = SWIG_AsVal_int(obj2, &val3);
39129 if (!SWIG_IsOK(ecode3)) {
39130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39131 }
39132 arg3 = static_cast< int >(val3);
39133 {
39134 arg4 = wxString_in_helper(obj3);
39135 if (arg4 == NULL) SWIG_fail;
39136 temp4 = true;
39137 }
39138 if (obj4) {
39139 {
39140 arg5 = wxString_in_helper(obj4);
39141 if (arg5 == NULL) SWIG_fail;
39142 temp5 = true;
39143 }
39144 }
39145 {
39146 PyThreadState* __tstate = wxPyBeginAllowThreads();
39147 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39148 wxPyEndAllowThreads(__tstate);
39149 if (PyErr_Occurred()) SWIG_fail;
39150 }
39151 {
39152 resultobj = wxPyMake_wxObject(result, (bool)0);
39153 }
39154 {
39155 if (temp4)
39156 delete arg4;
39157 }
39158 {
39159 if (temp5)
39160 delete arg5;
39161 }
39162 return resultobj;
39163 fail:
39164 {
39165 if (temp4)
39166 delete arg4;
39167 }
39168 {
39169 if (temp5)
39170 delete arg5;
39171 }
39172 return NULL;
39173 }
39174
39175
39176 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39177 PyObject *resultobj = 0;
39178 wxMenu *arg1 = (wxMenu *) 0 ;
39179 size_t arg2 ;
39180 int arg3 ;
39181 wxString *arg4 = 0 ;
39182 wxMenu *arg5 = (wxMenu *) 0 ;
39183 wxString const &arg6_defvalue = wxPyEmptyString ;
39184 wxString *arg6 = (wxString *) &arg6_defvalue ;
39185 wxMenuItem *result = 0 ;
39186 void *argp1 = 0 ;
39187 int res1 = 0 ;
39188 size_t val2 ;
39189 int ecode2 = 0 ;
39190 int val3 ;
39191 int ecode3 = 0 ;
39192 bool temp4 = false ;
39193 void *argp5 = 0 ;
39194 int res5 = 0 ;
39195 bool temp6 = false ;
39196 PyObject * obj0 = 0 ;
39197 PyObject * obj1 = 0 ;
39198 PyObject * obj2 = 0 ;
39199 PyObject * obj3 = 0 ;
39200 PyObject * obj4 = 0 ;
39201 PyObject * obj5 = 0 ;
39202 char * kwnames[] = {
39203 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39204 };
39205
39206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39208 if (!SWIG_IsOK(res1)) {
39209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39210 }
39211 arg1 = reinterpret_cast< wxMenu * >(argp1);
39212 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39213 if (!SWIG_IsOK(ecode2)) {
39214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39215 }
39216 arg2 = static_cast< size_t >(val2);
39217 ecode3 = SWIG_AsVal_int(obj2, &val3);
39218 if (!SWIG_IsOK(ecode3)) {
39219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39220 }
39221 arg3 = static_cast< int >(val3);
39222 {
39223 arg4 = wxString_in_helper(obj3);
39224 if (arg4 == NULL) SWIG_fail;
39225 temp4 = true;
39226 }
39227 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39228 if (!SWIG_IsOK(res5)) {
39229 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39230 }
39231 arg5 = reinterpret_cast< wxMenu * >(argp5);
39232 if (obj5) {
39233 {
39234 arg6 = wxString_in_helper(obj5);
39235 if (arg6 == NULL) SWIG_fail;
39236 temp6 = true;
39237 }
39238 }
39239 {
39240 PyThreadState* __tstate = wxPyBeginAllowThreads();
39241 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39242 wxPyEndAllowThreads(__tstate);
39243 if (PyErr_Occurred()) SWIG_fail;
39244 }
39245 {
39246 resultobj = wxPyMake_wxObject(result, (bool)0);
39247 }
39248 {
39249 if (temp4)
39250 delete arg4;
39251 }
39252 {
39253 if (temp6)
39254 delete arg6;
39255 }
39256 return resultobj;
39257 fail:
39258 {
39259 if (temp4)
39260 delete arg4;
39261 }
39262 {
39263 if (temp6)
39264 delete arg6;
39265 }
39266 return NULL;
39267 }
39268
39269
39270 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39271 PyObject *resultobj = 0;
39272 wxMenu *arg1 = (wxMenu *) 0 ;
39273 int arg2 ;
39274 wxString *arg3 = 0 ;
39275 wxString const &arg4_defvalue = wxPyEmptyString ;
39276 wxString *arg4 = (wxString *) &arg4_defvalue ;
39277 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39278 wxMenuItem *result = 0 ;
39279 void *argp1 = 0 ;
39280 int res1 = 0 ;
39281 int val2 ;
39282 int ecode2 = 0 ;
39283 bool temp3 = false ;
39284 bool temp4 = false ;
39285 int val5 ;
39286 int ecode5 = 0 ;
39287 PyObject * obj0 = 0 ;
39288 PyObject * obj1 = 0 ;
39289 PyObject * obj2 = 0 ;
39290 PyObject * obj3 = 0 ;
39291 PyObject * obj4 = 0 ;
39292 char * kwnames[] = {
39293 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39294 };
39295
39296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39298 if (!SWIG_IsOK(res1)) {
39299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39300 }
39301 arg1 = reinterpret_cast< wxMenu * >(argp1);
39302 ecode2 = SWIG_AsVal_int(obj1, &val2);
39303 if (!SWIG_IsOK(ecode2)) {
39304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39305 }
39306 arg2 = static_cast< int >(val2);
39307 {
39308 arg3 = wxString_in_helper(obj2);
39309 if (arg3 == NULL) SWIG_fail;
39310 temp3 = true;
39311 }
39312 if (obj3) {
39313 {
39314 arg4 = wxString_in_helper(obj3);
39315 if (arg4 == NULL) SWIG_fail;
39316 temp4 = true;
39317 }
39318 }
39319 if (obj4) {
39320 ecode5 = SWIG_AsVal_int(obj4, &val5);
39321 if (!SWIG_IsOK(ecode5)) {
39322 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39323 }
39324 arg5 = static_cast< wxItemKind >(val5);
39325 }
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 {
39333 resultobj = wxPyMake_wxObject(result, (bool)0);
39334 }
39335 {
39336 if (temp3)
39337 delete arg3;
39338 }
39339 {
39340 if (temp4)
39341 delete arg4;
39342 }
39343 return resultobj;
39344 fail:
39345 {
39346 if (temp3)
39347 delete arg3;
39348 }
39349 {
39350 if (temp4)
39351 delete arg4;
39352 }
39353 return NULL;
39354 }
39355
39356
39357 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39358 PyObject *resultobj = 0;
39359 wxMenu *arg1 = (wxMenu *) 0 ;
39360 wxMenuItem *result = 0 ;
39361 void *argp1 = 0 ;
39362 int res1 = 0 ;
39363 PyObject *swig_obj[1] ;
39364
39365 if (!args) SWIG_fail;
39366 swig_obj[0] = args;
39367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39370 }
39371 arg1 = reinterpret_cast< wxMenu * >(argp1);
39372 {
39373 PyThreadState* __tstate = wxPyBeginAllowThreads();
39374 result = (wxMenuItem *)(arg1)->PrependSeparator();
39375 wxPyEndAllowThreads(__tstate);
39376 if (PyErr_Occurred()) SWIG_fail;
39377 }
39378 {
39379 resultobj = wxPyMake_wxObject(result, (bool)0);
39380 }
39381 return resultobj;
39382 fail:
39383 return NULL;
39384 }
39385
39386
39387 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39388 PyObject *resultobj = 0;
39389 wxMenu *arg1 = (wxMenu *) 0 ;
39390 int arg2 ;
39391 wxString *arg3 = 0 ;
39392 wxString const &arg4_defvalue = wxPyEmptyString ;
39393 wxString *arg4 = (wxString *) &arg4_defvalue ;
39394 wxMenuItem *result = 0 ;
39395 void *argp1 = 0 ;
39396 int res1 = 0 ;
39397 int val2 ;
39398 int ecode2 = 0 ;
39399 bool temp3 = false ;
39400 bool temp4 = false ;
39401 PyObject * obj0 = 0 ;
39402 PyObject * obj1 = 0 ;
39403 PyObject * obj2 = 0 ;
39404 PyObject * obj3 = 0 ;
39405 char * kwnames[] = {
39406 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39407 };
39408
39409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39413 }
39414 arg1 = reinterpret_cast< wxMenu * >(argp1);
39415 ecode2 = SWIG_AsVal_int(obj1, &val2);
39416 if (!SWIG_IsOK(ecode2)) {
39417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39418 }
39419 arg2 = static_cast< int >(val2);
39420 {
39421 arg3 = wxString_in_helper(obj2);
39422 if (arg3 == NULL) SWIG_fail;
39423 temp3 = true;
39424 }
39425 if (obj3) {
39426 {
39427 arg4 = wxString_in_helper(obj3);
39428 if (arg4 == NULL) SWIG_fail;
39429 temp4 = true;
39430 }
39431 }
39432 {
39433 PyThreadState* __tstate = wxPyBeginAllowThreads();
39434 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39435 wxPyEndAllowThreads(__tstate);
39436 if (PyErr_Occurred()) SWIG_fail;
39437 }
39438 {
39439 resultobj = wxPyMake_wxObject(result, (bool)0);
39440 }
39441 {
39442 if (temp3)
39443 delete arg3;
39444 }
39445 {
39446 if (temp4)
39447 delete arg4;
39448 }
39449 return resultobj;
39450 fail:
39451 {
39452 if (temp3)
39453 delete arg3;
39454 }
39455 {
39456 if (temp4)
39457 delete arg4;
39458 }
39459 return NULL;
39460 }
39461
39462
39463 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39464 PyObject *resultobj = 0;
39465 wxMenu *arg1 = (wxMenu *) 0 ;
39466 int arg2 ;
39467 wxString *arg3 = 0 ;
39468 wxString const &arg4_defvalue = wxPyEmptyString ;
39469 wxString *arg4 = (wxString *) &arg4_defvalue ;
39470 wxMenuItem *result = 0 ;
39471 void *argp1 = 0 ;
39472 int res1 = 0 ;
39473 int val2 ;
39474 int ecode2 = 0 ;
39475 bool temp3 = false ;
39476 bool temp4 = false ;
39477 PyObject * obj0 = 0 ;
39478 PyObject * obj1 = 0 ;
39479 PyObject * obj2 = 0 ;
39480 PyObject * obj3 = 0 ;
39481 char * kwnames[] = {
39482 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39483 };
39484
39485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39487 if (!SWIG_IsOK(res1)) {
39488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39489 }
39490 arg1 = reinterpret_cast< wxMenu * >(argp1);
39491 ecode2 = SWIG_AsVal_int(obj1, &val2);
39492 if (!SWIG_IsOK(ecode2)) {
39493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39494 }
39495 arg2 = static_cast< int >(val2);
39496 {
39497 arg3 = wxString_in_helper(obj2);
39498 if (arg3 == NULL) SWIG_fail;
39499 temp3 = true;
39500 }
39501 if (obj3) {
39502 {
39503 arg4 = wxString_in_helper(obj3);
39504 if (arg4 == NULL) SWIG_fail;
39505 temp4 = true;
39506 }
39507 }
39508 {
39509 PyThreadState* __tstate = wxPyBeginAllowThreads();
39510 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39511 wxPyEndAllowThreads(__tstate);
39512 if (PyErr_Occurred()) SWIG_fail;
39513 }
39514 {
39515 resultobj = wxPyMake_wxObject(result, (bool)0);
39516 }
39517 {
39518 if (temp3)
39519 delete arg3;
39520 }
39521 {
39522 if (temp4)
39523 delete arg4;
39524 }
39525 return resultobj;
39526 fail:
39527 {
39528 if (temp3)
39529 delete arg3;
39530 }
39531 {
39532 if (temp4)
39533 delete arg4;
39534 }
39535 return NULL;
39536 }
39537
39538
39539 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39540 PyObject *resultobj = 0;
39541 wxMenu *arg1 = (wxMenu *) 0 ;
39542 int arg2 ;
39543 wxString *arg3 = 0 ;
39544 wxMenu *arg4 = (wxMenu *) 0 ;
39545 wxString const &arg5_defvalue = wxPyEmptyString ;
39546 wxString *arg5 = (wxString *) &arg5_defvalue ;
39547 wxMenuItem *result = 0 ;
39548 void *argp1 = 0 ;
39549 int res1 = 0 ;
39550 int val2 ;
39551 int ecode2 = 0 ;
39552 bool temp3 = false ;
39553 void *argp4 = 0 ;
39554 int res4 = 0 ;
39555 bool temp5 = false ;
39556 PyObject * obj0 = 0 ;
39557 PyObject * obj1 = 0 ;
39558 PyObject * obj2 = 0 ;
39559 PyObject * obj3 = 0 ;
39560 PyObject * obj4 = 0 ;
39561 char * kwnames[] = {
39562 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39563 };
39564
39565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39567 if (!SWIG_IsOK(res1)) {
39568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39569 }
39570 arg1 = reinterpret_cast< wxMenu * >(argp1);
39571 ecode2 = SWIG_AsVal_int(obj1, &val2);
39572 if (!SWIG_IsOK(ecode2)) {
39573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39574 }
39575 arg2 = static_cast< int >(val2);
39576 {
39577 arg3 = wxString_in_helper(obj2);
39578 if (arg3 == NULL) SWIG_fail;
39579 temp3 = true;
39580 }
39581 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39582 if (!SWIG_IsOK(res4)) {
39583 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39584 }
39585 arg4 = reinterpret_cast< wxMenu * >(argp4);
39586 if (obj4) {
39587 {
39588 arg5 = wxString_in_helper(obj4);
39589 if (arg5 == NULL) SWIG_fail;
39590 temp5 = true;
39591 }
39592 }
39593 {
39594 PyThreadState* __tstate = wxPyBeginAllowThreads();
39595 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39596 wxPyEndAllowThreads(__tstate);
39597 if (PyErr_Occurred()) SWIG_fail;
39598 }
39599 {
39600 resultobj = wxPyMake_wxObject(result, (bool)0);
39601 }
39602 {
39603 if (temp3)
39604 delete arg3;
39605 }
39606 {
39607 if (temp5)
39608 delete arg5;
39609 }
39610 return resultobj;
39611 fail:
39612 {
39613 if (temp3)
39614 delete arg3;
39615 }
39616 {
39617 if (temp5)
39618 delete arg5;
39619 }
39620 return NULL;
39621 }
39622
39623
39624 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39625 PyObject *resultobj = 0;
39626 wxMenu *arg1 = (wxMenu *) 0 ;
39627 int arg2 ;
39628 wxMenuItem *result = 0 ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 int val2 ;
39632 int ecode2 = 0 ;
39633 PyObject * obj0 = 0 ;
39634 PyObject * obj1 = 0 ;
39635 char * kwnames[] = {
39636 (char *) "self",(char *) "id", NULL
39637 };
39638
39639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39641 if (!SWIG_IsOK(res1)) {
39642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39643 }
39644 arg1 = reinterpret_cast< wxMenu * >(argp1);
39645 ecode2 = SWIG_AsVal_int(obj1, &val2);
39646 if (!SWIG_IsOK(ecode2)) {
39647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39648 }
39649 arg2 = static_cast< int >(val2);
39650 {
39651 PyThreadState* __tstate = wxPyBeginAllowThreads();
39652 result = (wxMenuItem *)(arg1)->Remove(arg2);
39653 wxPyEndAllowThreads(__tstate);
39654 if (PyErr_Occurred()) SWIG_fail;
39655 }
39656 {
39657 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39658 }
39659 return resultobj;
39660 fail:
39661 return NULL;
39662 }
39663
39664
39665 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39666 PyObject *resultobj = 0;
39667 wxMenu *arg1 = (wxMenu *) 0 ;
39668 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39669 wxMenuItem *result = 0 ;
39670 void *argp1 = 0 ;
39671 int res1 = 0 ;
39672 void *argp2 = 0 ;
39673 int res2 = 0 ;
39674 PyObject * obj0 = 0 ;
39675 PyObject * obj1 = 0 ;
39676 char * kwnames[] = {
39677 (char *) "self",(char *) "item", NULL
39678 };
39679
39680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39682 if (!SWIG_IsOK(res1)) {
39683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39684 }
39685 arg1 = reinterpret_cast< wxMenu * >(argp1);
39686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39687 if (!SWIG_IsOK(res2)) {
39688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39689 }
39690 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39691 {
39692 PyThreadState* __tstate = wxPyBeginAllowThreads();
39693 result = (wxMenuItem *)(arg1)->Remove(arg2);
39694 wxPyEndAllowThreads(__tstate);
39695 if (PyErr_Occurred()) SWIG_fail;
39696 }
39697 {
39698 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39699 }
39700 return resultobj;
39701 fail:
39702 return NULL;
39703 }
39704
39705
39706 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39707 PyObject *resultobj = 0;
39708 wxMenu *arg1 = (wxMenu *) 0 ;
39709 int arg2 ;
39710 bool result;
39711 void *argp1 = 0 ;
39712 int res1 = 0 ;
39713 int val2 ;
39714 int ecode2 = 0 ;
39715 PyObject * obj0 = 0 ;
39716 PyObject * obj1 = 0 ;
39717 char * kwnames[] = {
39718 (char *) "self",(char *) "id", NULL
39719 };
39720
39721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39723 if (!SWIG_IsOK(res1)) {
39724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39725 }
39726 arg1 = reinterpret_cast< wxMenu * >(argp1);
39727 ecode2 = SWIG_AsVal_int(obj1, &val2);
39728 if (!SWIG_IsOK(ecode2)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39730 }
39731 arg2 = static_cast< int >(val2);
39732 {
39733 PyThreadState* __tstate = wxPyBeginAllowThreads();
39734 result = (bool)(arg1)->Delete(arg2);
39735 wxPyEndAllowThreads(__tstate);
39736 if (PyErr_Occurred()) SWIG_fail;
39737 }
39738 {
39739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39740 }
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj = 0;
39749 wxMenu *arg1 = (wxMenu *) 0 ;
39750 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39751 bool result;
39752 void *argp1 = 0 ;
39753 int res1 = 0 ;
39754 void *argp2 = 0 ;
39755 int res2 = 0 ;
39756 PyObject * obj0 = 0 ;
39757 PyObject * obj1 = 0 ;
39758 char * kwnames[] = {
39759 (char *) "self",(char *) "item", NULL
39760 };
39761
39762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39764 if (!SWIG_IsOK(res1)) {
39765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39766 }
39767 arg1 = reinterpret_cast< wxMenu * >(argp1);
39768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39769 if (!SWIG_IsOK(res2)) {
39770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39771 }
39772 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39773 {
39774 PyThreadState* __tstate = wxPyBeginAllowThreads();
39775 result = (bool)(arg1)->Delete(arg2);
39776 wxPyEndAllowThreads(__tstate);
39777 if (PyErr_Occurred()) SWIG_fail;
39778 }
39779 {
39780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39781 }
39782 return resultobj;
39783 fail:
39784 return NULL;
39785 }
39786
39787
39788 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39789 PyObject *resultobj = 0;
39790 wxMenu *arg1 = (wxMenu *) 0 ;
39791 void *argp1 = 0 ;
39792 int res1 = 0 ;
39793 PyObject *swig_obj[1] ;
39794
39795 if (!args) SWIG_fail;
39796 swig_obj[0] = args;
39797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39798 if (!SWIG_IsOK(res1)) {
39799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39800 }
39801 arg1 = reinterpret_cast< wxMenu * >(argp1);
39802 {
39803 PyThreadState* __tstate = wxPyBeginAllowThreads();
39804 wxMenu_Destroy(arg1);
39805 wxPyEndAllowThreads(__tstate);
39806 if (PyErr_Occurred()) SWIG_fail;
39807 }
39808 resultobj = SWIG_Py_Void();
39809 return resultobj;
39810 fail:
39811 return NULL;
39812 }
39813
39814
39815 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj = 0;
39817 wxMenu *arg1 = (wxMenu *) 0 ;
39818 int arg2 ;
39819 bool result;
39820 void *argp1 = 0 ;
39821 int res1 = 0 ;
39822 int val2 ;
39823 int ecode2 = 0 ;
39824 PyObject * obj0 = 0 ;
39825 PyObject * obj1 = 0 ;
39826 char * kwnames[] = {
39827 (char *) "self",(char *) "id", NULL
39828 };
39829
39830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39832 if (!SWIG_IsOK(res1)) {
39833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39834 }
39835 arg1 = reinterpret_cast< wxMenu * >(argp1);
39836 ecode2 = SWIG_AsVal_int(obj1, &val2);
39837 if (!SWIG_IsOK(ecode2)) {
39838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39839 }
39840 arg2 = static_cast< int >(val2);
39841 {
39842 PyThreadState* __tstate = wxPyBeginAllowThreads();
39843 result = (bool)(arg1)->Destroy(arg2);
39844 wxPyEndAllowThreads(__tstate);
39845 if (PyErr_Occurred()) SWIG_fail;
39846 }
39847 {
39848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39849 }
39850 return resultobj;
39851 fail:
39852 return NULL;
39853 }
39854
39855
39856 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39857 PyObject *resultobj = 0;
39858 wxMenu *arg1 = (wxMenu *) 0 ;
39859 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39860 bool result;
39861 void *argp1 = 0 ;
39862 int res1 = 0 ;
39863 void *argp2 = 0 ;
39864 int res2 = 0 ;
39865 PyObject * obj0 = 0 ;
39866 PyObject * obj1 = 0 ;
39867 char * kwnames[] = {
39868 (char *) "self",(char *) "item", NULL
39869 };
39870
39871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39873 if (!SWIG_IsOK(res1)) {
39874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39875 }
39876 arg1 = reinterpret_cast< wxMenu * >(argp1);
39877 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39878 if (!SWIG_IsOK(res2)) {
39879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39880 }
39881 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 result = (bool)(arg1)->Destroy(arg2);
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 {
39889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39890 }
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39898 PyObject *resultobj = 0;
39899 wxMenu *arg1 = (wxMenu *) 0 ;
39900 size_t result;
39901 void *argp1 = 0 ;
39902 int res1 = 0 ;
39903 PyObject *swig_obj[1] ;
39904
39905 if (!args) SWIG_fail;
39906 swig_obj[0] = args;
39907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39910 }
39911 arg1 = reinterpret_cast< wxMenu * >(argp1);
39912 {
39913 PyThreadState* __tstate = wxPyBeginAllowThreads();
39914 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39915 wxPyEndAllowThreads(__tstate);
39916 if (PyErr_Occurred()) SWIG_fail;
39917 }
39918 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39926 PyObject *resultobj = 0;
39927 wxMenu *arg1 = (wxMenu *) 0 ;
39928 PyObject *result = 0 ;
39929 void *argp1 = 0 ;
39930 int res1 = 0 ;
39931 PyObject *swig_obj[1] ;
39932
39933 if (!args) SWIG_fail;
39934 swig_obj[0] = args;
39935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39936 if (!SWIG_IsOK(res1)) {
39937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39938 }
39939 arg1 = reinterpret_cast< wxMenu * >(argp1);
39940 {
39941 PyThreadState* __tstate = wxPyBeginAllowThreads();
39942 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 resultobj = result;
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj = 0;
39955 wxMenu *arg1 = (wxMenu *) 0 ;
39956 wxString *arg2 = 0 ;
39957 int result;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 bool temp2 = false ;
39961 PyObject * obj0 = 0 ;
39962 PyObject * obj1 = 0 ;
39963 char * kwnames[] = {
39964 (char *) "self",(char *) "item", NULL
39965 };
39966
39967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39969 if (!SWIG_IsOK(res1)) {
39970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39971 }
39972 arg1 = reinterpret_cast< wxMenu * >(argp1);
39973 {
39974 arg2 = wxString_in_helper(obj1);
39975 if (arg2 == NULL) SWIG_fail;
39976 temp2 = true;
39977 }
39978 {
39979 PyThreadState* __tstate = wxPyBeginAllowThreads();
39980 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39981 wxPyEndAllowThreads(__tstate);
39982 if (PyErr_Occurred()) SWIG_fail;
39983 }
39984 resultobj = SWIG_From_int(static_cast< int >(result));
39985 {
39986 if (temp2)
39987 delete arg2;
39988 }
39989 return resultobj;
39990 fail:
39991 {
39992 if (temp2)
39993 delete arg2;
39994 }
39995 return NULL;
39996 }
39997
39998
39999 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40000 PyObject *resultobj = 0;
40001 wxMenu *arg1 = (wxMenu *) 0 ;
40002 int arg2 ;
40003 wxMenuItem *result = 0 ;
40004 void *argp1 = 0 ;
40005 int res1 = 0 ;
40006 int val2 ;
40007 int ecode2 = 0 ;
40008 PyObject * obj0 = 0 ;
40009 PyObject * obj1 = 0 ;
40010 char * kwnames[] = {
40011 (char *) "self",(char *) "id", NULL
40012 };
40013
40014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40016 if (!SWIG_IsOK(res1)) {
40017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40018 }
40019 arg1 = reinterpret_cast< wxMenu * >(argp1);
40020 ecode2 = SWIG_AsVal_int(obj1, &val2);
40021 if (!SWIG_IsOK(ecode2)) {
40022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40023 }
40024 arg2 = static_cast< int >(val2);
40025 {
40026 PyThreadState* __tstate = wxPyBeginAllowThreads();
40027 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40028 wxPyEndAllowThreads(__tstate);
40029 if (PyErr_Occurred()) SWIG_fail;
40030 }
40031 {
40032 resultobj = wxPyMake_wxObject(result, (bool)0);
40033 }
40034 return resultobj;
40035 fail:
40036 return NULL;
40037 }
40038
40039
40040 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40041 PyObject *resultobj = 0;
40042 wxMenu *arg1 = (wxMenu *) 0 ;
40043 size_t arg2 ;
40044 wxMenuItem *result = 0 ;
40045 void *argp1 = 0 ;
40046 int res1 = 0 ;
40047 size_t val2 ;
40048 int ecode2 = 0 ;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 char * kwnames[] = {
40052 (char *) "self",(char *) "position", NULL
40053 };
40054
40055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40057 if (!SWIG_IsOK(res1)) {
40058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40059 }
40060 arg1 = reinterpret_cast< wxMenu * >(argp1);
40061 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40062 if (!SWIG_IsOK(ecode2)) {
40063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40064 }
40065 arg2 = static_cast< size_t >(val2);
40066 {
40067 PyThreadState* __tstate = wxPyBeginAllowThreads();
40068 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40069 wxPyEndAllowThreads(__tstate);
40070 if (PyErr_Occurred()) SWIG_fail;
40071 }
40072 {
40073 resultobj = wxPyMake_wxObject(result, (bool)0);
40074 }
40075 return resultobj;
40076 fail:
40077 return NULL;
40078 }
40079
40080
40081 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40082 PyObject *resultobj = 0;
40083 wxMenu *arg1 = (wxMenu *) 0 ;
40084 int arg2 ;
40085 bool arg3 ;
40086 void *argp1 = 0 ;
40087 int res1 = 0 ;
40088 int val2 ;
40089 int ecode2 = 0 ;
40090 bool val3 ;
40091 int ecode3 = 0 ;
40092 PyObject * obj0 = 0 ;
40093 PyObject * obj1 = 0 ;
40094 PyObject * obj2 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "id",(char *) "enable", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40103 }
40104 arg1 = reinterpret_cast< wxMenu * >(argp1);
40105 ecode2 = SWIG_AsVal_int(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40108 }
40109 arg2 = static_cast< int >(val2);
40110 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40111 if (!SWIG_IsOK(ecode3)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40113 }
40114 arg3 = static_cast< bool >(val3);
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 (arg1)->Enable(arg2,arg3);
40118 wxPyEndAllowThreads(__tstate);
40119 if (PyErr_Occurred()) SWIG_fail;
40120 }
40121 resultobj = SWIG_Py_Void();
40122 return resultobj;
40123 fail:
40124 return NULL;
40125 }
40126
40127
40128 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40129 PyObject *resultobj = 0;
40130 wxMenu *arg1 = (wxMenu *) 0 ;
40131 int arg2 ;
40132 bool result;
40133 void *argp1 = 0 ;
40134 int res1 = 0 ;
40135 int val2 ;
40136 int ecode2 = 0 ;
40137 PyObject * obj0 = 0 ;
40138 PyObject * obj1 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "id", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 {
40155 PyThreadState* __tstate = wxPyBeginAllowThreads();
40156 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 {
40161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40162 }
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40170 PyObject *resultobj = 0;
40171 wxMenu *arg1 = (wxMenu *) 0 ;
40172 int arg2 ;
40173 bool arg3 ;
40174 void *argp1 = 0 ;
40175 int res1 = 0 ;
40176 int val2 ;
40177 int ecode2 = 0 ;
40178 bool val3 ;
40179 int ecode3 = 0 ;
40180 PyObject * obj0 = 0 ;
40181 PyObject * obj1 = 0 ;
40182 PyObject * obj2 = 0 ;
40183 char * kwnames[] = {
40184 (char *) "self",(char *) "id",(char *) "check", NULL
40185 };
40186
40187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40191 }
40192 arg1 = reinterpret_cast< wxMenu * >(argp1);
40193 ecode2 = SWIG_AsVal_int(obj1, &val2);
40194 if (!SWIG_IsOK(ecode2)) {
40195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40196 }
40197 arg2 = static_cast< int >(val2);
40198 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40199 if (!SWIG_IsOK(ecode3)) {
40200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40201 }
40202 arg3 = static_cast< bool >(val3);
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 (arg1)->Check(arg2,arg3);
40206 wxPyEndAllowThreads(__tstate);
40207 if (PyErr_Occurred()) SWIG_fail;
40208 }
40209 resultobj = SWIG_Py_Void();
40210 return resultobj;
40211 fail:
40212 return NULL;
40213 }
40214
40215
40216 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40217 PyObject *resultobj = 0;
40218 wxMenu *arg1 = (wxMenu *) 0 ;
40219 int arg2 ;
40220 bool result;
40221 void *argp1 = 0 ;
40222 int res1 = 0 ;
40223 int val2 ;
40224 int ecode2 = 0 ;
40225 PyObject * obj0 = 0 ;
40226 PyObject * obj1 = 0 ;
40227 char * kwnames[] = {
40228 (char *) "self",(char *) "id", NULL
40229 };
40230
40231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40233 if (!SWIG_IsOK(res1)) {
40234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40235 }
40236 arg1 = reinterpret_cast< wxMenu * >(argp1);
40237 ecode2 = SWIG_AsVal_int(obj1, &val2);
40238 if (!SWIG_IsOK(ecode2)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40240 }
40241 arg2 = static_cast< int >(val2);
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 {
40249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40250 }
40251 return resultobj;
40252 fail:
40253 return NULL;
40254 }
40255
40256
40257 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40258 PyObject *resultobj = 0;
40259 wxMenu *arg1 = (wxMenu *) 0 ;
40260 int arg2 ;
40261 wxString *arg3 = 0 ;
40262 void *argp1 = 0 ;
40263 int res1 = 0 ;
40264 int val2 ;
40265 int ecode2 = 0 ;
40266 bool temp3 = false ;
40267 PyObject * obj0 = 0 ;
40268 PyObject * obj1 = 0 ;
40269 PyObject * obj2 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "id",(char *) "label", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 {
40286 arg3 = wxString_in_helper(obj2);
40287 if (arg3 == NULL) SWIG_fail;
40288 temp3 = true;
40289 }
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40293 wxPyEndAllowThreads(__tstate);
40294 if (PyErr_Occurred()) SWIG_fail;
40295 }
40296 resultobj = SWIG_Py_Void();
40297 {
40298 if (temp3)
40299 delete arg3;
40300 }
40301 return resultobj;
40302 fail:
40303 {
40304 if (temp3)
40305 delete arg3;
40306 }
40307 return NULL;
40308 }
40309
40310
40311 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40312 PyObject *resultobj = 0;
40313 wxMenu *arg1 = (wxMenu *) 0 ;
40314 int arg2 ;
40315 wxString result;
40316 void *argp1 = 0 ;
40317 int res1 = 0 ;
40318 int val2 ;
40319 int ecode2 = 0 ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 char * kwnames[] = {
40323 (char *) "self",(char *) "id", NULL
40324 };
40325
40326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40328 if (!SWIG_IsOK(res1)) {
40329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40330 }
40331 arg1 = reinterpret_cast< wxMenu * >(argp1);
40332 ecode2 = SWIG_AsVal_int(obj1, &val2);
40333 if (!SWIG_IsOK(ecode2)) {
40334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40335 }
40336 arg2 = static_cast< int >(val2);
40337 {
40338 PyThreadState* __tstate = wxPyBeginAllowThreads();
40339 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40340 wxPyEndAllowThreads(__tstate);
40341 if (PyErr_Occurred()) SWIG_fail;
40342 }
40343 {
40344 #if wxUSE_UNICODE
40345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40346 #else
40347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40348 #endif
40349 }
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj = 0;
40358 wxMenu *arg1 = (wxMenu *) 0 ;
40359 int arg2 ;
40360 wxString *arg3 = 0 ;
40361 void *argp1 = 0 ;
40362 int res1 = 0 ;
40363 int val2 ;
40364 int ecode2 = 0 ;
40365 bool temp3 = false ;
40366 PyObject * obj0 = 0 ;
40367 PyObject * obj1 = 0 ;
40368 PyObject * obj2 = 0 ;
40369 char * kwnames[] = {
40370 (char *) "self",(char *) "id",(char *) "helpString", NULL
40371 };
40372
40373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",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_SetHelpString" "', 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_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40382 }
40383 arg2 = static_cast< int >(val2);
40384 {
40385 arg3 = wxString_in_helper(obj2);
40386 if (arg3 == NULL) SWIG_fail;
40387 temp3 = true;
40388 }
40389 {
40390 PyThreadState* __tstate = wxPyBeginAllowThreads();
40391 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = SWIG_Py_Void();
40396 {
40397 if (temp3)
40398 delete arg3;
40399 }
40400 return resultobj;
40401 fail:
40402 {
40403 if (temp3)
40404 delete arg3;
40405 }
40406 return NULL;
40407 }
40408
40409
40410 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40411 PyObject *resultobj = 0;
40412 wxMenu *arg1 = (wxMenu *) 0 ;
40413 int arg2 ;
40414 wxString result;
40415 void *argp1 = 0 ;
40416 int res1 = 0 ;
40417 int val2 ;
40418 int ecode2 = 0 ;
40419 PyObject * obj0 = 0 ;
40420 PyObject * obj1 = 0 ;
40421 char * kwnames[] = {
40422 (char *) "self",(char *) "id", NULL
40423 };
40424
40425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40427 if (!SWIG_IsOK(res1)) {
40428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40429 }
40430 arg1 = reinterpret_cast< wxMenu * >(argp1);
40431 ecode2 = SWIG_AsVal_int(obj1, &val2);
40432 if (!SWIG_IsOK(ecode2)) {
40433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40434 }
40435 arg2 = static_cast< int >(val2);
40436 {
40437 PyThreadState* __tstate = wxPyBeginAllowThreads();
40438 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40439 wxPyEndAllowThreads(__tstate);
40440 if (PyErr_Occurred()) SWIG_fail;
40441 }
40442 {
40443 #if wxUSE_UNICODE
40444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40445 #else
40446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40447 #endif
40448 }
40449 return resultobj;
40450 fail:
40451 return NULL;
40452 }
40453
40454
40455 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40456 PyObject *resultobj = 0;
40457 wxMenu *arg1 = (wxMenu *) 0 ;
40458 wxString *arg2 = 0 ;
40459 void *argp1 = 0 ;
40460 int res1 = 0 ;
40461 bool temp2 = false ;
40462 PyObject * obj0 = 0 ;
40463 PyObject * obj1 = 0 ;
40464 char * kwnames[] = {
40465 (char *) "self",(char *) "title", NULL
40466 };
40467
40468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40470 if (!SWIG_IsOK(res1)) {
40471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40472 }
40473 arg1 = reinterpret_cast< wxMenu * >(argp1);
40474 {
40475 arg2 = wxString_in_helper(obj1);
40476 if (arg2 == NULL) SWIG_fail;
40477 temp2 = true;
40478 }
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 (arg1)->SetTitle((wxString const &)*arg2);
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 resultobj = SWIG_Py_Void();
40486 {
40487 if (temp2)
40488 delete arg2;
40489 }
40490 return resultobj;
40491 fail:
40492 {
40493 if (temp2)
40494 delete arg2;
40495 }
40496 return NULL;
40497 }
40498
40499
40500 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40501 PyObject *resultobj = 0;
40502 wxMenu *arg1 = (wxMenu *) 0 ;
40503 wxString result;
40504 void *argp1 = 0 ;
40505 int res1 = 0 ;
40506 PyObject *swig_obj[1] ;
40507
40508 if (!args) SWIG_fail;
40509 swig_obj[0] = args;
40510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40511 if (!SWIG_IsOK(res1)) {
40512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40513 }
40514 arg1 = reinterpret_cast< wxMenu * >(argp1);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 result = ((wxMenu const *)arg1)->GetTitle();
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 #if wxUSE_UNICODE
40523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40524 #else
40525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40526 #endif
40527 }
40528 return resultobj;
40529 fail:
40530 return NULL;
40531 }
40532
40533
40534 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40535 PyObject *resultobj = 0;
40536 wxMenu *arg1 = (wxMenu *) 0 ;
40537 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40538 void *argp1 = 0 ;
40539 int res1 = 0 ;
40540 void *argp2 = 0 ;
40541 int res2 = 0 ;
40542 PyObject * obj0 = 0 ;
40543 PyObject * obj1 = 0 ;
40544 char * kwnames[] = {
40545 (char *) "self",(char *) "handler", NULL
40546 };
40547
40548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) 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_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40555 if (!SWIG_IsOK(res2)) {
40556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40557 }
40558 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 (arg1)->SetEventHandler(arg2);
40562 wxPyEndAllowThreads(__tstate);
40563 if (PyErr_Occurred()) SWIG_fail;
40564 }
40565 resultobj = SWIG_Py_Void();
40566 return resultobj;
40567 fail:
40568 return NULL;
40569 }
40570
40571
40572 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40573 PyObject *resultobj = 0;
40574 wxMenu *arg1 = (wxMenu *) 0 ;
40575 wxEvtHandler *result = 0 ;
40576 void *argp1 = 0 ;
40577 int res1 = 0 ;
40578 PyObject *swig_obj[1] ;
40579
40580 if (!args) SWIG_fail;
40581 swig_obj[0] = args;
40582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40583 if (!SWIG_IsOK(res1)) {
40584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40585 }
40586 arg1 = reinterpret_cast< wxMenu * >(argp1);
40587 {
40588 PyThreadState* __tstate = wxPyBeginAllowThreads();
40589 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40590 wxPyEndAllowThreads(__tstate);
40591 if (PyErr_Occurred()) SWIG_fail;
40592 }
40593 {
40594 resultobj = wxPyMake_wxObject(result, 0);
40595 }
40596 return resultobj;
40597 fail:
40598 return NULL;
40599 }
40600
40601
40602 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40603 PyObject *resultobj = 0;
40604 wxMenu *arg1 = (wxMenu *) 0 ;
40605 wxWindow *arg2 = (wxWindow *) 0 ;
40606 void *argp1 = 0 ;
40607 int res1 = 0 ;
40608 void *argp2 = 0 ;
40609 int res2 = 0 ;
40610 PyObject * obj0 = 0 ;
40611 PyObject * obj1 = 0 ;
40612 char * kwnames[] = {
40613 (char *) "self",(char *) "win", NULL
40614 };
40615
40616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40618 if (!SWIG_IsOK(res1)) {
40619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40620 }
40621 arg1 = reinterpret_cast< wxMenu * >(argp1);
40622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40623 if (!SWIG_IsOK(res2)) {
40624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40625 }
40626 arg2 = reinterpret_cast< wxWindow * >(argp2);
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 (arg1)->SetInvokingWindow(arg2);
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 resultobj = SWIG_Py_Void();
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40641 PyObject *resultobj = 0;
40642 wxMenu *arg1 = (wxMenu *) 0 ;
40643 wxWindow *result = 0 ;
40644 void *argp1 = 0 ;
40645 int res1 = 0 ;
40646 PyObject *swig_obj[1] ;
40647
40648 if (!args) SWIG_fail;
40649 swig_obj[0] = args;
40650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40651 if (!SWIG_IsOK(res1)) {
40652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40653 }
40654 arg1 = reinterpret_cast< wxMenu * >(argp1);
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 {
40662 resultobj = wxPyMake_wxObject(result, 0);
40663 }
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40671 PyObject *resultobj = 0;
40672 wxMenu *arg1 = (wxMenu *) 0 ;
40673 long result;
40674 void *argp1 = 0 ;
40675 int res1 = 0 ;
40676 PyObject *swig_obj[1] ;
40677
40678 if (!args) SWIG_fail;
40679 swig_obj[0] = args;
40680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40681 if (!SWIG_IsOK(res1)) {
40682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40683 }
40684 arg1 = reinterpret_cast< wxMenu * >(argp1);
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = (long)((wxMenu const *)arg1)->GetStyle();
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 resultobj = SWIG_From_long(static_cast< long >(result));
40692 return resultobj;
40693 fail:
40694 return NULL;
40695 }
40696
40697
40698 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40699 PyObject *resultobj = 0;
40700 wxMenu *arg1 = (wxMenu *) 0 ;
40701 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40702 void *argp1 = 0 ;
40703 int res1 = 0 ;
40704 void *argp2 = 0 ;
40705 int res2 = 0 ;
40706 PyObject * obj0 = 0 ;
40707 PyObject * obj1 = 0 ;
40708 char * kwnames[] = {
40709 (char *) "self",(char *) "source", NULL
40710 };
40711
40712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40714 if (!SWIG_IsOK(res1)) {
40715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40716 }
40717 arg1 = reinterpret_cast< wxMenu * >(argp1);
40718 if (obj1) {
40719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40720 if (!SWIG_IsOK(res2)) {
40721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40722 }
40723 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40724 }
40725 {
40726 PyThreadState* __tstate = wxPyBeginAllowThreads();
40727 (arg1)->UpdateUI(arg2);
40728 wxPyEndAllowThreads(__tstate);
40729 if (PyErr_Occurred()) SWIG_fail;
40730 }
40731 resultobj = SWIG_Py_Void();
40732 return resultobj;
40733 fail:
40734 return NULL;
40735 }
40736
40737
40738 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40739 PyObject *resultobj = 0;
40740 wxMenu *arg1 = (wxMenu *) 0 ;
40741 wxMenuBar *result = 0 ;
40742 void *argp1 = 0 ;
40743 int res1 = 0 ;
40744 PyObject *swig_obj[1] ;
40745
40746 if (!args) SWIG_fail;
40747 swig_obj[0] = args;
40748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40749 if (!SWIG_IsOK(res1)) {
40750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40751 }
40752 arg1 = reinterpret_cast< wxMenu * >(argp1);
40753 {
40754 PyThreadState* __tstate = wxPyBeginAllowThreads();
40755 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40756 wxPyEndAllowThreads(__tstate);
40757 if (PyErr_Occurred()) SWIG_fail;
40758 }
40759 {
40760 resultobj = wxPyMake_wxObject(result, (bool)0);
40761 }
40762 return resultobj;
40763 fail:
40764 return NULL;
40765 }
40766
40767
40768 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40769 PyObject *resultobj = 0;
40770 wxMenu *arg1 = (wxMenu *) 0 ;
40771 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40772 void *argp1 = 0 ;
40773 int res1 = 0 ;
40774 void *argp2 = 0 ;
40775 int res2 = 0 ;
40776 PyObject * obj0 = 0 ;
40777 PyObject * obj1 = 0 ;
40778 char * kwnames[] = {
40779 (char *) "self",(char *) "menubar", NULL
40780 };
40781
40782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40784 if (!SWIG_IsOK(res1)) {
40785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40786 }
40787 arg1 = reinterpret_cast< wxMenu * >(argp1);
40788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40789 if (!SWIG_IsOK(res2)) {
40790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40791 }
40792 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40793 {
40794 PyThreadState* __tstate = wxPyBeginAllowThreads();
40795 (arg1)->Attach(arg2);
40796 wxPyEndAllowThreads(__tstate);
40797 if (PyErr_Occurred()) SWIG_fail;
40798 }
40799 resultobj = SWIG_Py_Void();
40800 return resultobj;
40801 fail:
40802 return NULL;
40803 }
40804
40805
40806 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40807 PyObject *resultobj = 0;
40808 wxMenu *arg1 = (wxMenu *) 0 ;
40809 void *argp1 = 0 ;
40810 int res1 = 0 ;
40811 PyObject *swig_obj[1] ;
40812
40813 if (!args) SWIG_fail;
40814 swig_obj[0] = args;
40815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40816 if (!SWIG_IsOK(res1)) {
40817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40818 }
40819 arg1 = reinterpret_cast< wxMenu * >(argp1);
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 (arg1)->Detach();
40823 wxPyEndAllowThreads(__tstate);
40824 if (PyErr_Occurred()) SWIG_fail;
40825 }
40826 resultobj = SWIG_Py_Void();
40827 return resultobj;
40828 fail:
40829 return NULL;
40830 }
40831
40832
40833 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40834 PyObject *resultobj = 0;
40835 wxMenu *arg1 = (wxMenu *) 0 ;
40836 bool result;
40837 void *argp1 = 0 ;
40838 int res1 = 0 ;
40839 PyObject *swig_obj[1] ;
40840
40841 if (!args) SWIG_fail;
40842 swig_obj[0] = args;
40843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40844 if (!SWIG_IsOK(res1)) {
40845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40846 }
40847 arg1 = reinterpret_cast< wxMenu * >(argp1);
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 result = (bool)((wxMenu const *)arg1)->IsAttached();
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 {
40855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40856 }
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj = 0;
40865 wxMenu *arg1 = (wxMenu *) 0 ;
40866 wxMenu *arg2 = (wxMenu *) 0 ;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 void *argp2 = 0 ;
40870 int res2 = 0 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 char * kwnames[] = {
40874 (char *) "self",(char *) "parent", NULL
40875 };
40876
40877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40879 if (!SWIG_IsOK(res1)) {
40880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40881 }
40882 arg1 = reinterpret_cast< wxMenu * >(argp1);
40883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res2)) {
40885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40886 }
40887 arg2 = reinterpret_cast< wxMenu * >(argp2);
40888 {
40889 PyThreadState* __tstate = wxPyBeginAllowThreads();
40890 (arg1)->SetParent(arg2);
40891 wxPyEndAllowThreads(__tstate);
40892 if (PyErr_Occurred()) SWIG_fail;
40893 }
40894 resultobj = SWIG_Py_Void();
40895 return resultobj;
40896 fail:
40897 return NULL;
40898 }
40899
40900
40901 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40902 PyObject *resultobj = 0;
40903 wxMenu *arg1 = (wxMenu *) 0 ;
40904 wxMenu *result = 0 ;
40905 void *argp1 = 0 ;
40906 int res1 = 0 ;
40907 PyObject *swig_obj[1] ;
40908
40909 if (!args) SWIG_fail;
40910 swig_obj[0] = args;
40911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40912 if (!SWIG_IsOK(res1)) {
40913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40914 }
40915 arg1 = reinterpret_cast< wxMenu * >(argp1);
40916 {
40917 PyThreadState* __tstate = wxPyBeginAllowThreads();
40918 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 {
40923 resultobj = wxPyMake_wxObject(result, 0);
40924 }
40925 return resultobj;
40926 fail:
40927 return NULL;
40928 }
40929
40930
40931 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40932 PyObject *obj;
40933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40934 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40935 return SWIG_Py_Void();
40936 }
40937
40938 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40939 return SWIG_Python_InitShadowInstance(args);
40940 }
40941
40942 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40943 PyObject *resultobj = 0;
40944 long arg1 = (long) 0 ;
40945 wxMenuBar *result = 0 ;
40946 long val1 ;
40947 int ecode1 = 0 ;
40948 PyObject * obj0 = 0 ;
40949 char * kwnames[] = {
40950 (char *) "style", NULL
40951 };
40952
40953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40954 if (obj0) {
40955 ecode1 = SWIG_AsVal_long(obj0, &val1);
40956 if (!SWIG_IsOK(ecode1)) {
40957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40958 }
40959 arg1 = static_cast< long >(val1);
40960 }
40961 {
40962 if (!wxPyCheckForApp()) SWIG_fail;
40963 PyThreadState* __tstate = wxPyBeginAllowThreads();
40964 result = (wxMenuBar *)new wxMenuBar(arg1);
40965 wxPyEndAllowThreads(__tstate);
40966 if (PyErr_Occurred()) SWIG_fail;
40967 }
40968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40969 return resultobj;
40970 fail:
40971 return NULL;
40972 }
40973
40974
40975 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40976 PyObject *resultobj = 0;
40977 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40978 wxMenu *arg2 = (wxMenu *) 0 ;
40979 wxString *arg3 = 0 ;
40980 bool result;
40981 void *argp1 = 0 ;
40982 int res1 = 0 ;
40983 void *argp2 = 0 ;
40984 int res2 = 0 ;
40985 bool temp3 = false ;
40986 PyObject * obj0 = 0 ;
40987 PyObject * obj1 = 0 ;
40988 PyObject * obj2 = 0 ;
40989 char * kwnames[] = {
40990 (char *) "self",(char *) "menu",(char *) "title", NULL
40991 };
40992
40993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40995 if (!SWIG_IsOK(res1)) {
40996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40997 }
40998 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41000 if (!SWIG_IsOK(res2)) {
41001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41002 }
41003 arg2 = reinterpret_cast< wxMenu * >(argp2);
41004 {
41005 arg3 = wxString_in_helper(obj2);
41006 if (arg3 == NULL) SWIG_fail;
41007 temp3 = true;
41008 }
41009 {
41010 PyThreadState* __tstate = wxPyBeginAllowThreads();
41011 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41012 wxPyEndAllowThreads(__tstate);
41013 if (PyErr_Occurred()) SWIG_fail;
41014 }
41015 {
41016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41017 }
41018 {
41019 if (temp3)
41020 delete arg3;
41021 }
41022 return resultobj;
41023 fail:
41024 {
41025 if (temp3)
41026 delete arg3;
41027 }
41028 return NULL;
41029 }
41030
41031
41032 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41033 PyObject *resultobj = 0;
41034 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41035 size_t arg2 ;
41036 wxMenu *arg3 = (wxMenu *) 0 ;
41037 wxString *arg4 = 0 ;
41038 bool result;
41039 void *argp1 = 0 ;
41040 int res1 = 0 ;
41041 size_t val2 ;
41042 int ecode2 = 0 ;
41043 void *argp3 = 0 ;
41044 int res3 = 0 ;
41045 bool temp4 = false ;
41046 PyObject * obj0 = 0 ;
41047 PyObject * obj1 = 0 ;
41048 PyObject * obj2 = 0 ;
41049 PyObject * obj3 = 0 ;
41050 char * kwnames[] = {
41051 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41052 };
41053
41054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41056 if (!SWIG_IsOK(res1)) {
41057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41058 }
41059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41060 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41061 if (!SWIG_IsOK(ecode2)) {
41062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41063 }
41064 arg2 = static_cast< size_t >(val2);
41065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41066 if (!SWIG_IsOK(res3)) {
41067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41068 }
41069 arg3 = reinterpret_cast< wxMenu * >(argp3);
41070 {
41071 arg4 = wxString_in_helper(obj3);
41072 if (arg4 == NULL) SWIG_fail;
41073 temp4 = true;
41074 }
41075 {
41076 PyThreadState* __tstate = wxPyBeginAllowThreads();
41077 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41078 wxPyEndAllowThreads(__tstate);
41079 if (PyErr_Occurred()) SWIG_fail;
41080 }
41081 {
41082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41083 }
41084 {
41085 if (temp4)
41086 delete arg4;
41087 }
41088 return resultobj;
41089 fail:
41090 {
41091 if (temp4)
41092 delete arg4;
41093 }
41094 return NULL;
41095 }
41096
41097
41098 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41099 PyObject *resultobj = 0;
41100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41101 size_t result;
41102 void *argp1 = 0 ;
41103 int res1 = 0 ;
41104 PyObject *swig_obj[1] ;
41105
41106 if (!args) SWIG_fail;
41107 swig_obj[0] = args;
41108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41109 if (!SWIG_IsOK(res1)) {
41110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41111 }
41112 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41113 {
41114 PyThreadState* __tstate = wxPyBeginAllowThreads();
41115 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41116 wxPyEndAllowThreads(__tstate);
41117 if (PyErr_Occurred()) SWIG_fail;
41118 }
41119 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41120 return resultobj;
41121 fail:
41122 return NULL;
41123 }
41124
41125
41126 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41127 PyObject *resultobj = 0;
41128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41129 size_t arg2 ;
41130 wxMenu *result = 0 ;
41131 void *argp1 = 0 ;
41132 int res1 = 0 ;
41133 size_t val2 ;
41134 int ecode2 = 0 ;
41135 PyObject * obj0 = 0 ;
41136 PyObject * obj1 = 0 ;
41137 char * kwnames[] = {
41138 (char *) "self",(char *) "pos", NULL
41139 };
41140
41141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41143 if (!SWIG_IsOK(res1)) {
41144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41145 }
41146 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41147 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41148 if (!SWIG_IsOK(ecode2)) {
41149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41150 }
41151 arg2 = static_cast< size_t >(val2);
41152 {
41153 PyThreadState* __tstate = wxPyBeginAllowThreads();
41154 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41155 wxPyEndAllowThreads(__tstate);
41156 if (PyErr_Occurred()) SWIG_fail;
41157 }
41158 {
41159 resultobj = wxPyMake_wxObject(result, 0);
41160 }
41161 return resultobj;
41162 fail:
41163 return NULL;
41164 }
41165
41166
41167 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41168 PyObject *resultobj = 0;
41169 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41170 size_t arg2 ;
41171 wxMenu *arg3 = (wxMenu *) 0 ;
41172 wxString *arg4 = 0 ;
41173 wxMenu *result = 0 ;
41174 void *argp1 = 0 ;
41175 int res1 = 0 ;
41176 size_t val2 ;
41177 int ecode2 = 0 ;
41178 void *argp3 = 0 ;
41179 int res3 = 0 ;
41180 bool temp4 = false ;
41181 PyObject * obj0 = 0 ;
41182 PyObject * obj1 = 0 ;
41183 PyObject * obj2 = 0 ;
41184 PyObject * obj3 = 0 ;
41185 char * kwnames[] = {
41186 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41187 };
41188
41189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41191 if (!SWIG_IsOK(res1)) {
41192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41193 }
41194 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41195 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41196 if (!SWIG_IsOK(ecode2)) {
41197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41198 }
41199 arg2 = static_cast< size_t >(val2);
41200 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41201 if (!SWIG_IsOK(res3)) {
41202 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41203 }
41204 arg3 = reinterpret_cast< wxMenu * >(argp3);
41205 {
41206 arg4 = wxString_in_helper(obj3);
41207 if (arg4 == NULL) SWIG_fail;
41208 temp4 = true;
41209 }
41210 {
41211 PyThreadState* __tstate = wxPyBeginAllowThreads();
41212 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41213 wxPyEndAllowThreads(__tstate);
41214 if (PyErr_Occurred()) SWIG_fail;
41215 }
41216 {
41217 resultobj = wxPyMake_wxObject(result, 0);
41218 }
41219 {
41220 if (temp4)
41221 delete arg4;
41222 }
41223 return resultobj;
41224 fail:
41225 {
41226 if (temp4)
41227 delete arg4;
41228 }
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = 0;
41235 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41236 size_t arg2 ;
41237 wxMenu *result = 0 ;
41238 void *argp1 = 0 ;
41239 int res1 = 0 ;
41240 size_t val2 ;
41241 int ecode2 = 0 ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "self",(char *) "pos", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41254 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41255 if (!SWIG_IsOK(ecode2)) {
41256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41257 }
41258 arg2 = static_cast< size_t >(val2);
41259 {
41260 PyThreadState* __tstate = wxPyBeginAllowThreads();
41261 result = (wxMenu *)(arg1)->Remove(arg2);
41262 wxPyEndAllowThreads(__tstate);
41263 if (PyErr_Occurred()) SWIG_fail;
41264 }
41265 {
41266 resultobj = wxPyMake_wxObject(result, 0);
41267 }
41268 return resultobj;
41269 fail:
41270 return NULL;
41271 }
41272
41273
41274 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41275 PyObject *resultobj = 0;
41276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41277 size_t arg2 ;
41278 bool arg3 ;
41279 void *argp1 = 0 ;
41280 int res1 = 0 ;
41281 size_t val2 ;
41282 int ecode2 = 0 ;
41283 bool val3 ;
41284 int ecode3 = 0 ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 PyObject * obj2 = 0 ;
41288 char * kwnames[] = {
41289 (char *) "self",(char *) "pos",(char *) "enable", NULL
41290 };
41291
41292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41294 if (!SWIG_IsOK(res1)) {
41295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41296 }
41297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41298 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41299 if (!SWIG_IsOK(ecode2)) {
41300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41301 }
41302 arg2 = static_cast< size_t >(val2);
41303 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41304 if (!SWIG_IsOK(ecode3)) {
41305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41306 }
41307 arg3 = static_cast< bool >(val3);
41308 {
41309 PyThreadState* __tstate = wxPyBeginAllowThreads();
41310 (arg1)->EnableTop(arg2,arg3);
41311 wxPyEndAllowThreads(__tstate);
41312 if (PyErr_Occurred()) SWIG_fail;
41313 }
41314 resultobj = SWIG_Py_Void();
41315 return resultobj;
41316 fail:
41317 return NULL;
41318 }
41319
41320
41321 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41322 PyObject *resultobj = 0;
41323 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41324 size_t arg2 ;
41325 bool result;
41326 void *argp1 = 0 ;
41327 int res1 = 0 ;
41328 size_t val2 ;
41329 int ecode2 = 0 ;
41330 PyObject * obj0 = 0 ;
41331 PyObject * obj1 = 0 ;
41332 char * kwnames[] = {
41333 (char *) "self",(char *) "pos", NULL
41334 };
41335
41336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41338 if (!SWIG_IsOK(res1)) {
41339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41340 }
41341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41342 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41343 if (!SWIG_IsOK(ecode2)) {
41344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41345 }
41346 arg2 = static_cast< size_t >(val2);
41347 {
41348 PyThreadState* __tstate = wxPyBeginAllowThreads();
41349 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 {
41354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41355 }
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj = 0;
41364 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41365 size_t arg2 ;
41366 wxString *arg3 = 0 ;
41367 void *argp1 = 0 ;
41368 int res1 = 0 ;
41369 size_t val2 ;
41370 int ecode2 = 0 ;
41371 bool temp3 = false ;
41372 PyObject * obj0 = 0 ;
41373 PyObject * obj1 = 0 ;
41374 PyObject * obj2 = 0 ;
41375 char * kwnames[] = {
41376 (char *) "self",(char *) "pos",(char *) "label", NULL
41377 };
41378
41379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41386 if (!SWIG_IsOK(ecode2)) {
41387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41388 }
41389 arg2 = static_cast< size_t >(val2);
41390 {
41391 arg3 = wxString_in_helper(obj2);
41392 if (arg3 == NULL) SWIG_fail;
41393 temp3 = true;
41394 }
41395 {
41396 PyThreadState* __tstate = wxPyBeginAllowThreads();
41397 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 resultobj = SWIG_Py_Void();
41402 {
41403 if (temp3)
41404 delete arg3;
41405 }
41406 return resultobj;
41407 fail:
41408 {
41409 if (temp3)
41410 delete arg3;
41411 }
41412 return NULL;
41413 }
41414
41415
41416 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41417 PyObject *resultobj = 0;
41418 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41419 size_t arg2 ;
41420 wxString result;
41421 void *argp1 = 0 ;
41422 int res1 = 0 ;
41423 size_t val2 ;
41424 int ecode2 = 0 ;
41425 PyObject * obj0 = 0 ;
41426 PyObject * obj1 = 0 ;
41427 char * kwnames[] = {
41428 (char *) "self",(char *) "pos", NULL
41429 };
41430
41431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41435 }
41436 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41438 if (!SWIG_IsOK(ecode2)) {
41439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41440 }
41441 arg2 = static_cast< size_t >(val2);
41442 {
41443 PyThreadState* __tstate = wxPyBeginAllowThreads();
41444 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 {
41449 #if wxUSE_UNICODE
41450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41451 #else
41452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41453 #endif
41454 }
41455 return resultobj;
41456 fail:
41457 return NULL;
41458 }
41459
41460
41461 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41462 PyObject *resultobj = 0;
41463 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41464 wxString *arg2 = 0 ;
41465 wxString *arg3 = 0 ;
41466 int result;
41467 void *argp1 = 0 ;
41468 int res1 = 0 ;
41469 bool temp2 = false ;
41470 bool temp3 = false ;
41471 PyObject * obj0 = 0 ;
41472 PyObject * obj1 = 0 ;
41473 PyObject * obj2 = 0 ;
41474 char * kwnames[] = {
41475 (char *) "self",(char *) "menu",(char *) "item", NULL
41476 };
41477
41478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41480 if (!SWIG_IsOK(res1)) {
41481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41482 }
41483 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41484 {
41485 arg2 = wxString_in_helper(obj1);
41486 if (arg2 == NULL) SWIG_fail;
41487 temp2 = true;
41488 }
41489 {
41490 arg3 = wxString_in_helper(obj2);
41491 if (arg3 == NULL) SWIG_fail;
41492 temp3 = true;
41493 }
41494 {
41495 PyThreadState* __tstate = wxPyBeginAllowThreads();
41496 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 resultobj = SWIG_From_int(static_cast< int >(result));
41501 {
41502 if (temp2)
41503 delete arg2;
41504 }
41505 {
41506 if (temp3)
41507 delete arg3;
41508 }
41509 return resultobj;
41510 fail:
41511 {
41512 if (temp2)
41513 delete arg2;
41514 }
41515 {
41516 if (temp3)
41517 delete arg3;
41518 }
41519 return NULL;
41520 }
41521
41522
41523 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41524 PyObject *resultobj = 0;
41525 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41526 int arg2 ;
41527 wxMenuItem *result = 0 ;
41528 void *argp1 = 0 ;
41529 int res1 = 0 ;
41530 int val2 ;
41531 int ecode2 = 0 ;
41532 PyObject * obj0 = 0 ;
41533 PyObject * obj1 = 0 ;
41534 char * kwnames[] = {
41535 (char *) "self",(char *) "id", NULL
41536 };
41537
41538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41540 if (!SWIG_IsOK(res1)) {
41541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41542 }
41543 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41544 ecode2 = SWIG_AsVal_int(obj1, &val2);
41545 if (!SWIG_IsOK(ecode2)) {
41546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41547 }
41548 arg2 = static_cast< int >(val2);
41549 {
41550 PyThreadState* __tstate = wxPyBeginAllowThreads();
41551 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41552 wxPyEndAllowThreads(__tstate);
41553 if (PyErr_Occurred()) SWIG_fail;
41554 }
41555 {
41556 resultobj = wxPyMake_wxObject(result, (bool)0);
41557 }
41558 return resultobj;
41559 fail:
41560 return NULL;
41561 }
41562
41563
41564 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41565 PyObject *resultobj = 0;
41566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41567 wxString *arg2 = 0 ;
41568 int result;
41569 void *argp1 = 0 ;
41570 int res1 = 0 ;
41571 bool temp2 = false ;
41572 PyObject * obj0 = 0 ;
41573 PyObject * obj1 = 0 ;
41574 char * kwnames[] = {
41575 (char *) "self",(char *) "title", NULL
41576 };
41577
41578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41580 if (!SWIG_IsOK(res1)) {
41581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41582 }
41583 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41584 {
41585 arg2 = wxString_in_helper(obj1);
41586 if (arg2 == NULL) SWIG_fail;
41587 temp2 = true;
41588 }
41589 {
41590 PyThreadState* __tstate = wxPyBeginAllowThreads();
41591 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41592 wxPyEndAllowThreads(__tstate);
41593 if (PyErr_Occurred()) SWIG_fail;
41594 }
41595 resultobj = SWIG_From_int(static_cast< int >(result));
41596 {
41597 if (temp2)
41598 delete arg2;
41599 }
41600 return resultobj;
41601 fail:
41602 {
41603 if (temp2)
41604 delete arg2;
41605 }
41606 return NULL;
41607 }
41608
41609
41610 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41611 PyObject *resultobj = 0;
41612 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41613 int arg2 ;
41614 bool arg3 ;
41615 void *argp1 = 0 ;
41616 int res1 = 0 ;
41617 int val2 ;
41618 int ecode2 = 0 ;
41619 bool val3 ;
41620 int ecode3 = 0 ;
41621 PyObject * obj0 = 0 ;
41622 PyObject * obj1 = 0 ;
41623 PyObject * obj2 = 0 ;
41624 char * kwnames[] = {
41625 (char *) "self",(char *) "id",(char *) "enable", NULL
41626 };
41627
41628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41630 if (!SWIG_IsOK(res1)) {
41631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41632 }
41633 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41634 ecode2 = SWIG_AsVal_int(obj1, &val2);
41635 if (!SWIG_IsOK(ecode2)) {
41636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41637 }
41638 arg2 = static_cast< int >(val2);
41639 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41640 if (!SWIG_IsOK(ecode3)) {
41641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41642 }
41643 arg3 = static_cast< bool >(val3);
41644 {
41645 PyThreadState* __tstate = wxPyBeginAllowThreads();
41646 (arg1)->Enable(arg2,arg3);
41647 wxPyEndAllowThreads(__tstate);
41648 if (PyErr_Occurred()) SWIG_fail;
41649 }
41650 resultobj = SWIG_Py_Void();
41651 return resultobj;
41652 fail:
41653 return NULL;
41654 }
41655
41656
41657 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41658 PyObject *resultobj = 0;
41659 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41660 int arg2 ;
41661 bool arg3 ;
41662 void *argp1 = 0 ;
41663 int res1 = 0 ;
41664 int val2 ;
41665 int ecode2 = 0 ;
41666 bool val3 ;
41667 int ecode3 = 0 ;
41668 PyObject * obj0 = 0 ;
41669 PyObject * obj1 = 0 ;
41670 PyObject * obj2 = 0 ;
41671 char * kwnames[] = {
41672 (char *) "self",(char *) "id",(char *) "check", NULL
41673 };
41674
41675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41677 if (!SWIG_IsOK(res1)) {
41678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41679 }
41680 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41681 ecode2 = SWIG_AsVal_int(obj1, &val2);
41682 if (!SWIG_IsOK(ecode2)) {
41683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41684 }
41685 arg2 = static_cast< int >(val2);
41686 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41687 if (!SWIG_IsOK(ecode3)) {
41688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41689 }
41690 arg3 = static_cast< bool >(val3);
41691 {
41692 PyThreadState* __tstate = wxPyBeginAllowThreads();
41693 (arg1)->Check(arg2,arg3);
41694 wxPyEndAllowThreads(__tstate);
41695 if (PyErr_Occurred()) SWIG_fail;
41696 }
41697 resultobj = SWIG_Py_Void();
41698 return resultobj;
41699 fail:
41700 return NULL;
41701 }
41702
41703
41704 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41705 PyObject *resultobj = 0;
41706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41707 int arg2 ;
41708 bool result;
41709 void *argp1 = 0 ;
41710 int res1 = 0 ;
41711 int val2 ;
41712 int ecode2 = 0 ;
41713 PyObject * obj0 = 0 ;
41714 PyObject * obj1 = 0 ;
41715 char * kwnames[] = {
41716 (char *) "self",(char *) "id", NULL
41717 };
41718
41719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41721 if (!SWIG_IsOK(res1)) {
41722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41723 }
41724 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41725 ecode2 = SWIG_AsVal_int(obj1, &val2);
41726 if (!SWIG_IsOK(ecode2)) {
41727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41728 }
41729 arg2 = static_cast< int >(val2);
41730 {
41731 PyThreadState* __tstate = wxPyBeginAllowThreads();
41732 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41733 wxPyEndAllowThreads(__tstate);
41734 if (PyErr_Occurred()) SWIG_fail;
41735 }
41736 {
41737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41738 }
41739 return resultobj;
41740 fail:
41741 return NULL;
41742 }
41743
41744
41745 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41746 PyObject *resultobj = 0;
41747 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41748 int arg2 ;
41749 bool result;
41750 void *argp1 = 0 ;
41751 int res1 = 0 ;
41752 int val2 ;
41753 int ecode2 = 0 ;
41754 PyObject * obj0 = 0 ;
41755 PyObject * obj1 = 0 ;
41756 char * kwnames[] = {
41757 (char *) "self",(char *) "id", NULL
41758 };
41759
41760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41762 if (!SWIG_IsOK(res1)) {
41763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41764 }
41765 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41766 ecode2 = SWIG_AsVal_int(obj1, &val2);
41767 if (!SWIG_IsOK(ecode2)) {
41768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41769 }
41770 arg2 = static_cast< int >(val2);
41771 {
41772 PyThreadState* __tstate = wxPyBeginAllowThreads();
41773 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41774 wxPyEndAllowThreads(__tstate);
41775 if (PyErr_Occurred()) SWIG_fail;
41776 }
41777 {
41778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41779 }
41780 return resultobj;
41781 fail:
41782 return NULL;
41783 }
41784
41785
41786 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41787 PyObject *resultobj = 0;
41788 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41789 int arg2 ;
41790 wxString *arg3 = 0 ;
41791 void *argp1 = 0 ;
41792 int res1 = 0 ;
41793 int val2 ;
41794 int ecode2 = 0 ;
41795 bool temp3 = false ;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 PyObject * obj2 = 0 ;
41799 char * kwnames[] = {
41800 (char *) "self",(char *) "id",(char *) "label", NULL
41801 };
41802
41803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41805 if (!SWIG_IsOK(res1)) {
41806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41807 }
41808 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41809 ecode2 = SWIG_AsVal_int(obj1, &val2);
41810 if (!SWIG_IsOK(ecode2)) {
41811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41812 }
41813 arg2 = static_cast< int >(val2);
41814 {
41815 arg3 = wxString_in_helper(obj2);
41816 if (arg3 == NULL) SWIG_fail;
41817 temp3 = true;
41818 }
41819 {
41820 PyThreadState* __tstate = wxPyBeginAllowThreads();
41821 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41822 wxPyEndAllowThreads(__tstate);
41823 if (PyErr_Occurred()) SWIG_fail;
41824 }
41825 resultobj = SWIG_Py_Void();
41826 {
41827 if (temp3)
41828 delete arg3;
41829 }
41830 return resultobj;
41831 fail:
41832 {
41833 if (temp3)
41834 delete arg3;
41835 }
41836 return NULL;
41837 }
41838
41839
41840 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41841 PyObject *resultobj = 0;
41842 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41843 int arg2 ;
41844 wxString result;
41845 void *argp1 = 0 ;
41846 int res1 = 0 ;
41847 int val2 ;
41848 int ecode2 = 0 ;
41849 PyObject * obj0 = 0 ;
41850 PyObject * obj1 = 0 ;
41851 char * kwnames[] = {
41852 (char *) "self",(char *) "id", NULL
41853 };
41854
41855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41857 if (!SWIG_IsOK(res1)) {
41858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41859 }
41860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41861 ecode2 = SWIG_AsVal_int(obj1, &val2);
41862 if (!SWIG_IsOK(ecode2)) {
41863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41864 }
41865 arg2 = static_cast< int >(val2);
41866 {
41867 PyThreadState* __tstate = wxPyBeginAllowThreads();
41868 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41869 wxPyEndAllowThreads(__tstate);
41870 if (PyErr_Occurred()) SWIG_fail;
41871 }
41872 {
41873 #if wxUSE_UNICODE
41874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41875 #else
41876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41877 #endif
41878 }
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj = 0;
41887 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41888 int arg2 ;
41889 wxString *arg3 = 0 ;
41890 void *argp1 = 0 ;
41891 int res1 = 0 ;
41892 int val2 ;
41893 int ecode2 = 0 ;
41894 bool temp3 = false ;
41895 PyObject * obj0 = 0 ;
41896 PyObject * obj1 = 0 ;
41897 PyObject * obj2 = 0 ;
41898 char * kwnames[] = {
41899 (char *) "self",(char *) "id",(char *) "helpString", NULL
41900 };
41901
41902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",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_SetHelpString" "', 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_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41911 }
41912 arg2 = static_cast< int >(val2);
41913 {
41914 arg3 = wxString_in_helper(obj2);
41915 if (arg3 == NULL) SWIG_fail;
41916 temp3 = true;
41917 }
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 resultobj = SWIG_Py_Void();
41925 {
41926 if (temp3)
41927 delete arg3;
41928 }
41929 return resultobj;
41930 fail:
41931 {
41932 if (temp3)
41933 delete arg3;
41934 }
41935 return NULL;
41936 }
41937
41938
41939 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41940 PyObject *resultobj = 0;
41941 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41942 int arg2 ;
41943 wxString result;
41944 void *argp1 = 0 ;
41945 int res1 = 0 ;
41946 int val2 ;
41947 int ecode2 = 0 ;
41948 PyObject * obj0 = 0 ;
41949 PyObject * obj1 = 0 ;
41950 char * kwnames[] = {
41951 (char *) "self",(char *) "id", NULL
41952 };
41953
41954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41956 if (!SWIG_IsOK(res1)) {
41957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41958 }
41959 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41960 ecode2 = SWIG_AsVal_int(obj1, &val2);
41961 if (!SWIG_IsOK(ecode2)) {
41962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41963 }
41964 arg2 = static_cast< int >(val2);
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 {
41972 #if wxUSE_UNICODE
41973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41974 #else
41975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41976 #endif
41977 }
41978 return resultobj;
41979 fail:
41980 return NULL;
41981 }
41982
41983
41984 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41985 PyObject *resultobj = 0;
41986 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41987 wxFrame *result = 0 ;
41988 void *argp1 = 0 ;
41989 int res1 = 0 ;
41990 PyObject *swig_obj[1] ;
41991
41992 if (!args) SWIG_fail;
41993 swig_obj[0] = args;
41994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41995 if (!SWIG_IsOK(res1)) {
41996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41997 }
41998 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41999 {
42000 PyThreadState* __tstate = wxPyBeginAllowThreads();
42001 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42002 wxPyEndAllowThreads(__tstate);
42003 if (PyErr_Occurred()) SWIG_fail;
42004 }
42005 {
42006 resultobj = wxPyMake_wxObject(result, (bool)0);
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42015 PyObject *resultobj = 0;
42016 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42017 bool result;
42018 void *argp1 = 0 ;
42019 int res1 = 0 ;
42020 PyObject *swig_obj[1] ;
42021
42022 if (!args) SWIG_fail;
42023 swig_obj[0] = args;
42024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 {
42036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42037 }
42038 return resultobj;
42039 fail:
42040 return NULL;
42041 }
42042
42043
42044 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42045 PyObject *resultobj = 0;
42046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42047 wxFrame *arg2 = (wxFrame *) 0 ;
42048 void *argp1 = 0 ;
42049 int res1 = 0 ;
42050 void *argp2 = 0 ;
42051 int res2 = 0 ;
42052 PyObject * obj0 = 0 ;
42053 PyObject * obj1 = 0 ;
42054 char * kwnames[] = {
42055 (char *) "self",(char *) "frame", NULL
42056 };
42057
42058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42060 if (!SWIG_IsOK(res1)) {
42061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42062 }
42063 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42065 if (!SWIG_IsOK(res2)) {
42066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42067 }
42068 arg2 = reinterpret_cast< wxFrame * >(argp2);
42069 {
42070 PyThreadState* __tstate = wxPyBeginAllowThreads();
42071 (arg1)->Attach(arg2);
42072 wxPyEndAllowThreads(__tstate);
42073 if (PyErr_Occurred()) SWIG_fail;
42074 }
42075 resultobj = SWIG_Py_Void();
42076 return resultobj;
42077 fail:
42078 return NULL;
42079 }
42080
42081
42082 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42083 PyObject *resultobj = 0;
42084 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42085 void *argp1 = 0 ;
42086 int res1 = 0 ;
42087 PyObject *swig_obj[1] ;
42088
42089 if (!args) SWIG_fail;
42090 swig_obj[0] = args;
42091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42092 if (!SWIG_IsOK(res1)) {
42093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42094 }
42095 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 (arg1)->Detach();
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 resultobj = SWIG_Py_Void();
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42110 PyObject *resultobj = 0;
42111 bool arg1 ;
42112 bool val1 ;
42113 int ecode1 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 char * kwnames[] = {
42116 (char *) "enable", NULL
42117 };
42118
42119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42120 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42121 if (!SWIG_IsOK(ecode1)) {
42122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42123 }
42124 arg1 = static_cast< bool >(val1);
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 wxMenuBar_SetAutoWindowMenu(arg1);
42128 wxPyEndAllowThreads(__tstate);
42129 if (PyErr_Occurred()) SWIG_fail;
42130 }
42131 resultobj = SWIG_Py_Void();
42132 return resultobj;
42133 fail:
42134 return NULL;
42135 }
42136
42137
42138 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42139 PyObject *resultobj = 0;
42140 bool result;
42141
42142 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = (bool)wxMenuBar_GetAutoWindowMenu();
42146 wxPyEndAllowThreads(__tstate);
42147 if (PyErr_Occurred()) SWIG_fail;
42148 }
42149 {
42150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42151 }
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42159 PyObject *obj;
42160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42161 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42162 return SWIG_Py_Void();
42163 }
42164
42165 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42166 return SWIG_Python_InitShadowInstance(args);
42167 }
42168
42169 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42170 PyObject *resultobj = 0;
42171 wxMenu *arg1 = (wxMenu *) NULL ;
42172 int arg2 = (int) wxID_ANY ;
42173 wxString const &arg3_defvalue = wxPyEmptyString ;
42174 wxString *arg3 = (wxString *) &arg3_defvalue ;
42175 wxString const &arg4_defvalue = wxPyEmptyString ;
42176 wxString *arg4 = (wxString *) &arg4_defvalue ;
42177 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42178 wxMenu *arg6 = (wxMenu *) NULL ;
42179 wxMenuItem *result = 0 ;
42180 void *argp1 = 0 ;
42181 int res1 = 0 ;
42182 int val2 ;
42183 int ecode2 = 0 ;
42184 bool temp3 = false ;
42185 bool temp4 = false ;
42186 int val5 ;
42187 int ecode5 = 0 ;
42188 void *argp6 = 0 ;
42189 int res6 = 0 ;
42190 PyObject * obj0 = 0 ;
42191 PyObject * obj1 = 0 ;
42192 PyObject * obj2 = 0 ;
42193 PyObject * obj3 = 0 ;
42194 PyObject * obj4 = 0 ;
42195 PyObject * obj5 = 0 ;
42196 char * kwnames[] = {
42197 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42198 };
42199
42200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42201 if (obj0) {
42202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42203 if (!SWIG_IsOK(res1)) {
42204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42205 }
42206 arg1 = reinterpret_cast< wxMenu * >(argp1);
42207 }
42208 if (obj1) {
42209 ecode2 = SWIG_AsVal_int(obj1, &val2);
42210 if (!SWIG_IsOK(ecode2)) {
42211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42212 }
42213 arg2 = static_cast< int >(val2);
42214 }
42215 if (obj2) {
42216 {
42217 arg3 = wxString_in_helper(obj2);
42218 if (arg3 == NULL) SWIG_fail;
42219 temp3 = true;
42220 }
42221 }
42222 if (obj3) {
42223 {
42224 arg4 = wxString_in_helper(obj3);
42225 if (arg4 == NULL) SWIG_fail;
42226 temp4 = true;
42227 }
42228 }
42229 if (obj4) {
42230 ecode5 = SWIG_AsVal_int(obj4, &val5);
42231 if (!SWIG_IsOK(ecode5)) {
42232 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42233 }
42234 arg5 = static_cast< wxItemKind >(val5);
42235 }
42236 if (obj5) {
42237 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42238 if (!SWIG_IsOK(res6)) {
42239 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42240 }
42241 arg6 = reinterpret_cast< wxMenu * >(argp6);
42242 }
42243 {
42244 PyThreadState* __tstate = wxPyBeginAllowThreads();
42245 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42246 wxPyEndAllowThreads(__tstate);
42247 if (PyErr_Occurred()) SWIG_fail;
42248 }
42249 {
42250 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42251 }
42252 {
42253 if (temp3)
42254 delete arg3;
42255 }
42256 {
42257 if (temp4)
42258 delete arg4;
42259 }
42260 return resultobj;
42261 fail:
42262 {
42263 if (temp3)
42264 delete arg3;
42265 }
42266 {
42267 if (temp4)
42268 delete arg4;
42269 }
42270 return NULL;
42271 }
42272
42273
42274 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42275 PyObject *resultobj = 0;
42276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42277 void *argp1 = 0 ;
42278 int res1 = 0 ;
42279 PyObject *swig_obj[1] ;
42280
42281 if (!args) SWIG_fail;
42282 swig_obj[0] = args;
42283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42284 if (!SWIG_IsOK(res1)) {
42285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42286 }
42287 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42288 {
42289 PyThreadState* __tstate = wxPyBeginAllowThreads();
42290 delete arg1;
42291
42292 wxPyEndAllowThreads(__tstate);
42293 if (PyErr_Occurred()) SWIG_fail;
42294 }
42295 resultobj = SWIG_Py_Void();
42296 return resultobj;
42297 fail:
42298 return NULL;
42299 }
42300
42301
42302 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42303 PyObject *resultobj = 0;
42304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42305 wxMenu *result = 0 ;
42306 void *argp1 = 0 ;
42307 int res1 = 0 ;
42308 PyObject *swig_obj[1] ;
42309
42310 if (!args) SWIG_fail;
42311 swig_obj[0] = args;
42312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42313 if (!SWIG_IsOK(res1)) {
42314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42315 }
42316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42317 {
42318 PyThreadState* __tstate = wxPyBeginAllowThreads();
42319 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 {
42324 resultobj = wxPyMake_wxObject(result, 0);
42325 }
42326 return resultobj;
42327 fail:
42328 return NULL;
42329 }
42330
42331
42332 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42333 PyObject *resultobj = 0;
42334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42335 wxMenu *arg2 = (wxMenu *) 0 ;
42336 void *argp1 = 0 ;
42337 int res1 = 0 ;
42338 void *argp2 = 0 ;
42339 int res2 = 0 ;
42340 PyObject * obj0 = 0 ;
42341 PyObject * obj1 = 0 ;
42342 char * kwnames[] = {
42343 (char *) "self",(char *) "menu", NULL
42344 };
42345
42346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42348 if (!SWIG_IsOK(res1)) {
42349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42350 }
42351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42353 if (!SWIG_IsOK(res2)) {
42354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42355 }
42356 arg2 = reinterpret_cast< wxMenu * >(argp2);
42357 {
42358 PyThreadState* __tstate = wxPyBeginAllowThreads();
42359 (arg1)->SetMenu(arg2);
42360 wxPyEndAllowThreads(__tstate);
42361 if (PyErr_Occurred()) SWIG_fail;
42362 }
42363 resultobj = SWIG_Py_Void();
42364 return resultobj;
42365 fail:
42366 return NULL;
42367 }
42368
42369
42370 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42371 PyObject *resultobj = 0;
42372 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42373 int arg2 ;
42374 void *argp1 = 0 ;
42375 int res1 = 0 ;
42376 int val2 ;
42377 int ecode2 = 0 ;
42378 PyObject * obj0 = 0 ;
42379 PyObject * obj1 = 0 ;
42380 char * kwnames[] = {
42381 (char *) "self",(char *) "id", NULL
42382 };
42383
42384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42386 if (!SWIG_IsOK(res1)) {
42387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42388 }
42389 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42390 ecode2 = SWIG_AsVal_int(obj1, &val2);
42391 if (!SWIG_IsOK(ecode2)) {
42392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42393 }
42394 arg2 = static_cast< int >(val2);
42395 {
42396 PyThreadState* __tstate = wxPyBeginAllowThreads();
42397 (arg1)->SetId(arg2);
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 resultobj = SWIG_Py_Void();
42402 return resultobj;
42403 fail:
42404 return NULL;
42405 }
42406
42407
42408 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42409 PyObject *resultobj = 0;
42410 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42411 int result;
42412 void *argp1 = 0 ;
42413 int res1 = 0 ;
42414 PyObject *swig_obj[1] ;
42415
42416 if (!args) SWIG_fail;
42417 swig_obj[0] = args;
42418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42419 if (!SWIG_IsOK(res1)) {
42420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42421 }
42422 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42423 {
42424 PyThreadState* __tstate = wxPyBeginAllowThreads();
42425 result = (int)((wxMenuItem const *)arg1)->GetId();
42426 wxPyEndAllowThreads(__tstate);
42427 if (PyErr_Occurred()) SWIG_fail;
42428 }
42429 resultobj = SWIG_From_int(static_cast< int >(result));
42430 return resultobj;
42431 fail:
42432 return NULL;
42433 }
42434
42435
42436 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42437 PyObject *resultobj = 0;
42438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42439 bool result;
42440 void *argp1 = 0 ;
42441 int res1 = 0 ;
42442 PyObject *swig_obj[1] ;
42443
42444 if (!args) SWIG_fail;
42445 swig_obj[0] = args;
42446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42447 if (!SWIG_IsOK(res1)) {
42448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42449 }
42450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42451 {
42452 PyThreadState* __tstate = wxPyBeginAllowThreads();
42453 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 {
42458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42459 }
42460 return resultobj;
42461 fail:
42462 return NULL;
42463 }
42464
42465
42466 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42467 PyObject *resultobj = 0;
42468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42469 wxString *arg2 = 0 ;
42470 void *argp1 = 0 ;
42471 int res1 = 0 ;
42472 bool temp2 = false ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 char * kwnames[] = {
42476 (char *) "self",(char *) "str", NULL
42477 };
42478
42479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42485 {
42486 arg2 = wxString_in_helper(obj1);
42487 if (arg2 == NULL) SWIG_fail;
42488 temp2 = true;
42489 }
42490 {
42491 PyThreadState* __tstate = wxPyBeginAllowThreads();
42492 (arg1)->SetText((wxString const &)*arg2);
42493 wxPyEndAllowThreads(__tstate);
42494 if (PyErr_Occurred()) SWIG_fail;
42495 }
42496 resultobj = SWIG_Py_Void();
42497 {
42498 if (temp2)
42499 delete arg2;
42500 }
42501 return resultobj;
42502 fail:
42503 {
42504 if (temp2)
42505 delete arg2;
42506 }
42507 return NULL;
42508 }
42509
42510
42511 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42512 PyObject *resultobj = 0;
42513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42514 wxString result;
42515 void *argp1 = 0 ;
42516 int res1 = 0 ;
42517 PyObject *swig_obj[1] ;
42518
42519 if (!args) SWIG_fail;
42520 swig_obj[0] = args;
42521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42522 if (!SWIG_IsOK(res1)) {
42523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42524 }
42525 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 result = ((wxMenuItem const *)arg1)->GetLabel();
42529 wxPyEndAllowThreads(__tstate);
42530 if (PyErr_Occurred()) SWIG_fail;
42531 }
42532 {
42533 #if wxUSE_UNICODE
42534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42535 #else
42536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42537 #endif
42538 }
42539 return resultobj;
42540 fail:
42541 return NULL;
42542 }
42543
42544
42545 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42546 PyObject *resultobj = 0;
42547 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42548 wxString *result = 0 ;
42549 void *argp1 = 0 ;
42550 int res1 = 0 ;
42551 PyObject *swig_obj[1] ;
42552
42553 if (!args) SWIG_fail;
42554 swig_obj[0] = args;
42555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42556 if (!SWIG_IsOK(res1)) {
42557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42558 }
42559 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 {
42563 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42564 result = (wxString *) &_result_ref;
42565 }
42566 wxPyEndAllowThreads(__tstate);
42567 if (PyErr_Occurred()) SWIG_fail;
42568 }
42569 {
42570 #if wxUSE_UNICODE
42571 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42572 #else
42573 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42574 #endif
42575 }
42576 return resultobj;
42577 fail:
42578 return NULL;
42579 }
42580
42581
42582 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42583 PyObject *resultobj = 0;
42584 wxString *arg1 = 0 ;
42585 wxString result;
42586 bool temp1 = false ;
42587 PyObject * obj0 = 0 ;
42588 char * kwnames[] = {
42589 (char *) "text", NULL
42590 };
42591
42592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42593 {
42594 arg1 = wxString_in_helper(obj0);
42595 if (arg1 == NULL) SWIG_fail;
42596 temp1 = true;
42597 }
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42601 wxPyEndAllowThreads(__tstate);
42602 if (PyErr_Occurred()) SWIG_fail;
42603 }
42604 {
42605 #if wxUSE_UNICODE
42606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42607 #else
42608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42609 #endif
42610 }
42611 {
42612 if (temp1)
42613 delete arg1;
42614 }
42615 return resultobj;
42616 fail:
42617 {
42618 if (temp1)
42619 delete arg1;
42620 }
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42626 PyObject *resultobj = 0;
42627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42628 wxItemKind result;
42629 void *argp1 = 0 ;
42630 int res1 = 0 ;
42631 PyObject *swig_obj[1] ;
42632
42633 if (!args) SWIG_fail;
42634 swig_obj[0] = args;
42635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42636 if (!SWIG_IsOK(res1)) {
42637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42638 }
42639 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 resultobj = SWIG_From_int(static_cast< int >(result));
42647 return resultobj;
42648 fail:
42649 return NULL;
42650 }
42651
42652
42653 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42654 PyObject *resultobj = 0;
42655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42656 wxItemKind arg2 ;
42657 void *argp1 = 0 ;
42658 int res1 = 0 ;
42659 int val2 ;
42660 int ecode2 = 0 ;
42661 PyObject * obj0 = 0 ;
42662 PyObject * obj1 = 0 ;
42663 char * kwnames[] = {
42664 (char *) "self",(char *) "kind", NULL
42665 };
42666
42667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42669 if (!SWIG_IsOK(res1)) {
42670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42671 }
42672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42673 ecode2 = SWIG_AsVal_int(obj1, &val2);
42674 if (!SWIG_IsOK(ecode2)) {
42675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42676 }
42677 arg2 = static_cast< wxItemKind >(val2);
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 (arg1)->SetKind(arg2);
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 resultobj = SWIG_Py_Void();
42685 return resultobj;
42686 fail:
42687 return NULL;
42688 }
42689
42690
42691 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42692 PyObject *resultobj = 0;
42693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42694 bool arg2 ;
42695 void *argp1 = 0 ;
42696 int res1 = 0 ;
42697 bool val2 ;
42698 int ecode2 = 0 ;
42699 PyObject * obj0 = 0 ;
42700 PyObject * obj1 = 0 ;
42701 char * kwnames[] = {
42702 (char *) "self",(char *) "checkable", NULL
42703 };
42704
42705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42707 if (!SWIG_IsOK(res1)) {
42708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42709 }
42710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42712 if (!SWIG_IsOK(ecode2)) {
42713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42714 }
42715 arg2 = static_cast< bool >(val2);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 (arg1)->SetCheckable(arg2);
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 resultobj = SWIG_Py_Void();
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42730 PyObject *resultobj = 0;
42731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42732 bool result;
42733 void *argp1 = 0 ;
42734 int res1 = 0 ;
42735 PyObject *swig_obj[1] ;
42736
42737 if (!args) SWIG_fail;
42738 swig_obj[0] = args;
42739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 {
42751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42752 }
42753 return resultobj;
42754 fail:
42755 return NULL;
42756 }
42757
42758
42759 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42760 PyObject *resultobj = 0;
42761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42762 bool result;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 PyObject *swig_obj[1] ;
42766
42767 if (!args) SWIG_fail;
42768 swig_obj[0] = args;
42769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42770 if (!SWIG_IsOK(res1)) {
42771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42772 }
42773 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42774 {
42775 PyThreadState* __tstate = wxPyBeginAllowThreads();
42776 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42777 wxPyEndAllowThreads(__tstate);
42778 if (PyErr_Occurred()) SWIG_fail;
42779 }
42780 {
42781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42782 }
42783 return resultobj;
42784 fail:
42785 return NULL;
42786 }
42787
42788
42789 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42790 PyObject *resultobj = 0;
42791 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42792 wxMenu *arg2 = (wxMenu *) 0 ;
42793 void *argp1 = 0 ;
42794 int res1 = 0 ;
42795 void *argp2 = 0 ;
42796 int res2 = 0 ;
42797 PyObject * obj0 = 0 ;
42798 PyObject * obj1 = 0 ;
42799 char * kwnames[] = {
42800 (char *) "self",(char *) "menu", NULL
42801 };
42802
42803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42805 if (!SWIG_IsOK(res1)) {
42806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42807 }
42808 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42810 if (!SWIG_IsOK(res2)) {
42811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42812 }
42813 arg2 = reinterpret_cast< wxMenu * >(argp2);
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 (arg1)->SetSubMenu(arg2);
42817 wxPyEndAllowThreads(__tstate);
42818 if (PyErr_Occurred()) SWIG_fail;
42819 }
42820 resultobj = SWIG_Py_Void();
42821 return resultobj;
42822 fail:
42823 return NULL;
42824 }
42825
42826
42827 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42828 PyObject *resultobj = 0;
42829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42830 wxMenu *result = 0 ;
42831 void *argp1 = 0 ;
42832 int res1 = 0 ;
42833 PyObject *swig_obj[1] ;
42834
42835 if (!args) SWIG_fail;
42836 swig_obj[0] = args;
42837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42838 if (!SWIG_IsOK(res1)) {
42839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42840 }
42841 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42845 wxPyEndAllowThreads(__tstate);
42846 if (PyErr_Occurred()) SWIG_fail;
42847 }
42848 {
42849 resultobj = wxPyMake_wxObject(result, 0);
42850 }
42851 return resultobj;
42852 fail:
42853 return NULL;
42854 }
42855
42856
42857 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42858 PyObject *resultobj = 0;
42859 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42860 bool arg2 = (bool) true ;
42861 void *argp1 = 0 ;
42862 int res1 = 0 ;
42863 bool val2 ;
42864 int ecode2 = 0 ;
42865 PyObject * obj0 = 0 ;
42866 PyObject * obj1 = 0 ;
42867 char * kwnames[] = {
42868 (char *) "self",(char *) "enable", NULL
42869 };
42870
42871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42873 if (!SWIG_IsOK(res1)) {
42874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42875 }
42876 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42877 if (obj1) {
42878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42879 if (!SWIG_IsOK(ecode2)) {
42880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42881 }
42882 arg2 = static_cast< bool >(val2);
42883 }
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 (arg1)->Enable(arg2);
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 resultobj = SWIG_Py_Void();
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42898 PyObject *resultobj = 0;
42899 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42900 bool result;
42901 void *argp1 = 0 ;
42902 int res1 = 0 ;
42903 PyObject *swig_obj[1] ;
42904
42905 if (!args) SWIG_fail;
42906 swig_obj[0] = args;
42907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42908 if (!SWIG_IsOK(res1)) {
42909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42910 }
42911 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42912 {
42913 PyThreadState* __tstate = wxPyBeginAllowThreads();
42914 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42915 wxPyEndAllowThreads(__tstate);
42916 if (PyErr_Occurred()) SWIG_fail;
42917 }
42918 {
42919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42920 }
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42930 bool arg2 = (bool) true ;
42931 void *argp1 = 0 ;
42932 int res1 = 0 ;
42933 bool val2 ;
42934 int ecode2 = 0 ;
42935 PyObject * obj0 = 0 ;
42936 PyObject * obj1 = 0 ;
42937 char * kwnames[] = {
42938 (char *) "self",(char *) "check", NULL
42939 };
42940
42941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42943 if (!SWIG_IsOK(res1)) {
42944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42945 }
42946 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42947 if (obj1) {
42948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42949 if (!SWIG_IsOK(ecode2)) {
42950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42951 }
42952 arg2 = static_cast< bool >(val2);
42953 }
42954 {
42955 PyThreadState* __tstate = wxPyBeginAllowThreads();
42956 (arg1)->Check(arg2);
42957 wxPyEndAllowThreads(__tstate);
42958 if (PyErr_Occurred()) SWIG_fail;
42959 }
42960 resultobj = SWIG_Py_Void();
42961 return resultobj;
42962 fail:
42963 return NULL;
42964 }
42965
42966
42967 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42968 PyObject *resultobj = 0;
42969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42970 bool result;
42971 void *argp1 = 0 ;
42972 int res1 = 0 ;
42973 PyObject *swig_obj[1] ;
42974
42975 if (!args) SWIG_fail;
42976 swig_obj[0] = args;
42977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42978 if (!SWIG_IsOK(res1)) {
42979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42980 }
42981 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 {
42989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42990 }
42991 return resultobj;
42992 fail:
42993 return NULL;
42994 }
42995
42996
42997 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42998 PyObject *resultobj = 0;
42999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43000 void *argp1 = 0 ;
43001 int res1 = 0 ;
43002 PyObject *swig_obj[1] ;
43003
43004 if (!args) SWIG_fail;
43005 swig_obj[0] = args;
43006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43007 if (!SWIG_IsOK(res1)) {
43008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43009 }
43010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 (arg1)->Toggle();
43014 wxPyEndAllowThreads(__tstate);
43015 if (PyErr_Occurred()) SWIG_fail;
43016 }
43017 resultobj = SWIG_Py_Void();
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43025 PyObject *resultobj = 0;
43026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43027 wxString *arg2 = 0 ;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 bool temp2 = false ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 char * kwnames[] = {
43034 (char *) "self",(char *) "str", NULL
43035 };
43036
43037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 {
43044 arg2 = wxString_in_helper(obj1);
43045 if (arg2 == NULL) SWIG_fail;
43046 temp2 = true;
43047 }
43048 {
43049 PyThreadState* __tstate = wxPyBeginAllowThreads();
43050 (arg1)->SetHelp((wxString const &)*arg2);
43051 wxPyEndAllowThreads(__tstate);
43052 if (PyErr_Occurred()) SWIG_fail;
43053 }
43054 resultobj = SWIG_Py_Void();
43055 {
43056 if (temp2)
43057 delete arg2;
43058 }
43059 return resultobj;
43060 fail:
43061 {
43062 if (temp2)
43063 delete arg2;
43064 }
43065 return NULL;
43066 }
43067
43068
43069 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43070 PyObject *resultobj = 0;
43071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43072 wxString *result = 0 ;
43073 void *argp1 = 0 ;
43074 int res1 = 0 ;
43075 PyObject *swig_obj[1] ;
43076
43077 if (!args) SWIG_fail;
43078 swig_obj[0] = args;
43079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43080 if (!SWIG_IsOK(res1)) {
43081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43082 }
43083 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 {
43087 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43088 result = (wxString *) &_result_ref;
43089 }
43090 wxPyEndAllowThreads(__tstate);
43091 if (PyErr_Occurred()) SWIG_fail;
43092 }
43093 {
43094 #if wxUSE_UNICODE
43095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43096 #else
43097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43098 #endif
43099 }
43100 return resultobj;
43101 fail:
43102 return NULL;
43103 }
43104
43105
43106 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43107 PyObject *resultobj = 0;
43108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43109 wxAcceleratorEntry *result = 0 ;
43110 void *argp1 = 0 ;
43111 int res1 = 0 ;
43112 PyObject *swig_obj[1] ;
43113
43114 if (!args) SWIG_fail;
43115 swig_obj[0] = args;
43116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43117 if (!SWIG_IsOK(res1)) {
43118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43119 }
43120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43124 wxPyEndAllowThreads(__tstate);
43125 if (PyErr_Occurred()) SWIG_fail;
43126 }
43127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43128 return resultobj;
43129 fail:
43130 return NULL;
43131 }
43132
43133
43134 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43135 PyObject *resultobj = 0;
43136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43137 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43138 void *argp1 = 0 ;
43139 int res1 = 0 ;
43140 void *argp2 = 0 ;
43141 int res2 = 0 ;
43142 PyObject * obj0 = 0 ;
43143 PyObject * obj1 = 0 ;
43144 char * kwnames[] = {
43145 (char *) "self",(char *) "accel", NULL
43146 };
43147
43148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43150 if (!SWIG_IsOK(res1)) {
43151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43152 }
43153 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43155 if (!SWIG_IsOK(res2)) {
43156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43157 }
43158 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 (arg1)->SetAccel(arg2);
43162 wxPyEndAllowThreads(__tstate);
43163 if (PyErr_Occurred()) SWIG_fail;
43164 }
43165 resultobj = SWIG_Py_Void();
43166 return resultobj;
43167 fail:
43168 return NULL;
43169 }
43170
43171
43172 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43173 PyObject *resultobj = 0;
43174 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43175 wxBitmap *arg2 = 0 ;
43176 void *argp1 = 0 ;
43177 int res1 = 0 ;
43178 void *argp2 = 0 ;
43179 int res2 = 0 ;
43180 PyObject * obj0 = 0 ;
43181 PyObject * obj1 = 0 ;
43182 char * kwnames[] = {
43183 (char *) "self",(char *) "bitmap", NULL
43184 };
43185
43186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43188 if (!SWIG_IsOK(res1)) {
43189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43190 }
43191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43192 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43193 if (!SWIG_IsOK(res2)) {
43194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43195 }
43196 if (!argp2) {
43197 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43198 }
43199 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43200 {
43201 PyThreadState* __tstate = wxPyBeginAllowThreads();
43202 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43203 wxPyEndAllowThreads(__tstate);
43204 if (PyErr_Occurred()) SWIG_fail;
43205 }
43206 resultobj = SWIG_Py_Void();
43207 return resultobj;
43208 fail:
43209 return NULL;
43210 }
43211
43212
43213 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43214 PyObject *resultobj = 0;
43215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43216 wxBitmap *result = 0 ;
43217 void *argp1 = 0 ;
43218 int res1 = 0 ;
43219 PyObject *swig_obj[1] ;
43220
43221 if (!args) SWIG_fail;
43222 swig_obj[0] = args;
43223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43224 if (!SWIG_IsOK(res1)) {
43225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43226 }
43227 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43228 {
43229 PyThreadState* __tstate = wxPyBeginAllowThreads();
43230 {
43231 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43232 result = (wxBitmap *) &_result_ref;
43233 }
43234 wxPyEndAllowThreads(__tstate);
43235 if (PyErr_Occurred()) SWIG_fail;
43236 }
43237 {
43238 wxBitmap* resultptr = new wxBitmap(*result);
43239 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43240 }
43241 return resultobj;
43242 fail:
43243 return NULL;
43244 }
43245
43246
43247 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43248 PyObject *resultobj = 0;
43249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43250 wxFont *arg2 = 0 ;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 void *argp2 = 0 ;
43254 int res2 = 0 ;
43255 PyObject * obj0 = 0 ;
43256 PyObject * obj1 = 0 ;
43257 char * kwnames[] = {
43258 (char *) "self",(char *) "font", NULL
43259 };
43260
43261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43263 if (!SWIG_IsOK(res1)) {
43264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43265 }
43266 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43267 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43268 if (!SWIG_IsOK(res2)) {
43269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43270 }
43271 if (!argp2) {
43272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43273 }
43274 arg2 = reinterpret_cast< wxFont * >(argp2);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 resultobj = SWIG_Py_Void();
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43289 PyObject *resultobj = 0;
43290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43291 wxFont result;
43292 void *argp1 = 0 ;
43293 int res1 = 0 ;
43294 PyObject *swig_obj[1] ;
43295
43296 if (!args) SWIG_fail;
43297 swig_obj[0] = args;
43298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43299 if (!SWIG_IsOK(res1)) {
43300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43301 }
43302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 result = wxMenuItem_GetFont(arg1);
43306 wxPyEndAllowThreads(__tstate);
43307 if (PyErr_Occurred()) SWIG_fail;
43308 }
43309 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43317 PyObject *resultobj = 0;
43318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43319 wxColour *arg2 = 0 ;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 wxColour temp2 ;
43323 PyObject * obj0 = 0 ;
43324 PyObject * obj1 = 0 ;
43325 char * kwnames[] = {
43326 (char *) "self",(char *) "colText", NULL
43327 };
43328
43329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43331 if (!SWIG_IsOK(res1)) {
43332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43333 }
43334 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43335 {
43336 arg2 = &temp2;
43337 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43338 }
43339 {
43340 PyThreadState* __tstate = wxPyBeginAllowThreads();
43341 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43342 wxPyEndAllowThreads(__tstate);
43343 if (PyErr_Occurred()) SWIG_fail;
43344 }
43345 resultobj = SWIG_Py_Void();
43346 return resultobj;
43347 fail:
43348 return NULL;
43349 }
43350
43351
43352 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43353 PyObject *resultobj = 0;
43354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43355 wxColour result;
43356 void *argp1 = 0 ;
43357 int res1 = 0 ;
43358 PyObject *swig_obj[1] ;
43359
43360 if (!args) SWIG_fail;
43361 swig_obj[0] = args;
43362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 result = wxMenuItem_GetTextColour(arg1);
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43381 PyObject *resultobj = 0;
43382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43383 wxColour *arg2 = 0 ;
43384 void *argp1 = 0 ;
43385 int res1 = 0 ;
43386 wxColour temp2 ;
43387 PyObject * obj0 = 0 ;
43388 PyObject * obj1 = 0 ;
43389 char * kwnames[] = {
43390 (char *) "self",(char *) "colBack", NULL
43391 };
43392
43393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43395 if (!SWIG_IsOK(res1)) {
43396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43397 }
43398 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43399 {
43400 arg2 = &temp2;
43401 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43402 }
43403 {
43404 PyThreadState* __tstate = wxPyBeginAllowThreads();
43405 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43406 wxPyEndAllowThreads(__tstate);
43407 if (PyErr_Occurred()) SWIG_fail;
43408 }
43409 resultobj = SWIG_Py_Void();
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43417 PyObject *resultobj = 0;
43418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43419 wxColour result;
43420 void *argp1 = 0 ;
43421 int res1 = 0 ;
43422 PyObject *swig_obj[1] ;
43423
43424 if (!args) SWIG_fail;
43425 swig_obj[0] = args;
43426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43427 if (!SWIG_IsOK(res1)) {
43428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43429 }
43430 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43431 {
43432 PyThreadState* __tstate = wxPyBeginAllowThreads();
43433 result = wxMenuItem_GetBackgroundColour(arg1);
43434 wxPyEndAllowThreads(__tstate);
43435 if (PyErr_Occurred()) SWIG_fail;
43436 }
43437 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43445 PyObject *resultobj = 0;
43446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43447 wxBitmap *arg2 = 0 ;
43448 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43449 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43450 void *argp1 = 0 ;
43451 int res1 = 0 ;
43452 void *argp2 = 0 ;
43453 int res2 = 0 ;
43454 void *argp3 = 0 ;
43455 int res3 = 0 ;
43456 PyObject * obj0 = 0 ;
43457 PyObject * obj1 = 0 ;
43458 PyObject * obj2 = 0 ;
43459 char * kwnames[] = {
43460 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43461 };
43462
43463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43465 if (!SWIG_IsOK(res1)) {
43466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43467 }
43468 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43470 if (!SWIG_IsOK(res2)) {
43471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43472 }
43473 if (!argp2) {
43474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43475 }
43476 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43477 if (obj2) {
43478 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43479 if (!SWIG_IsOK(res3)) {
43480 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43481 }
43482 if (!argp3) {
43483 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43484 }
43485 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43486 }
43487 {
43488 PyThreadState* __tstate = wxPyBeginAllowThreads();
43489 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43490 wxPyEndAllowThreads(__tstate);
43491 if (PyErr_Occurred()) SWIG_fail;
43492 }
43493 resultobj = SWIG_Py_Void();
43494 return resultobj;
43495 fail:
43496 return NULL;
43497 }
43498
43499
43500 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43501 PyObject *resultobj = 0;
43502 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43503 wxBitmap *arg2 = 0 ;
43504 void *argp1 = 0 ;
43505 int res1 = 0 ;
43506 void *argp2 = 0 ;
43507 int res2 = 0 ;
43508 PyObject * obj0 = 0 ;
43509 PyObject * obj1 = 0 ;
43510 char * kwnames[] = {
43511 (char *) "self",(char *) "bmpDisabled", NULL
43512 };
43513
43514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43520 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43521 if (!SWIG_IsOK(res2)) {
43522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43523 }
43524 if (!argp2) {
43525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43526 }
43527 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43528 {
43529 PyThreadState* __tstate = wxPyBeginAllowThreads();
43530 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43531 wxPyEndAllowThreads(__tstate);
43532 if (PyErr_Occurred()) SWIG_fail;
43533 }
43534 resultobj = SWIG_Py_Void();
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43542 PyObject *resultobj = 0;
43543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43544 wxBitmap *result = 0 ;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 PyObject *swig_obj[1] ;
43548
43549 if (!args) SWIG_fail;
43550 swig_obj[0] = args;
43551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43552 if (!SWIG_IsOK(res1)) {
43553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43554 }
43555 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43556 {
43557 PyThreadState* __tstate = wxPyBeginAllowThreads();
43558 {
43559 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43560 result = (wxBitmap *) &_result_ref;
43561 }
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 {
43566 wxBitmap* resultptr = new wxBitmap(*result);
43567 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43568 }
43569 return resultobj;
43570 fail:
43571 return NULL;
43572 }
43573
43574
43575 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43576 PyObject *resultobj = 0;
43577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43578 int arg2 ;
43579 void *argp1 = 0 ;
43580 int res1 = 0 ;
43581 int val2 ;
43582 int ecode2 = 0 ;
43583 PyObject * obj0 = 0 ;
43584 PyObject * obj1 = 0 ;
43585 char * kwnames[] = {
43586 (char *) "self",(char *) "nWidth", NULL
43587 };
43588
43589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43591 if (!SWIG_IsOK(res1)) {
43592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43593 }
43594 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43595 ecode2 = SWIG_AsVal_int(obj1, &val2);
43596 if (!SWIG_IsOK(ecode2)) {
43597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43598 }
43599 arg2 = static_cast< int >(val2);
43600 {
43601 PyThreadState* __tstate = wxPyBeginAllowThreads();
43602 wxMenuItem_SetMarginWidth(arg1,arg2);
43603 wxPyEndAllowThreads(__tstate);
43604 if (PyErr_Occurred()) SWIG_fail;
43605 }
43606 resultobj = SWIG_Py_Void();
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43614 PyObject *resultobj = 0;
43615 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43616 int result;
43617 void *argp1 = 0 ;
43618 int res1 = 0 ;
43619 PyObject *swig_obj[1] ;
43620
43621 if (!args) SWIG_fail;
43622 swig_obj[0] = args;
43623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43624 if (!SWIG_IsOK(res1)) {
43625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43626 }
43627 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43628 {
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 result = (int)wxMenuItem_GetMarginWidth(arg1);
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 resultobj = SWIG_From_int(static_cast< int >(result));
43635 return resultobj;
43636 fail:
43637 return NULL;
43638 }
43639
43640
43641 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43642 PyObject *resultobj = 0;
43643 int result;
43644
43645 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43646 {
43647 PyThreadState* __tstate = wxPyBeginAllowThreads();
43648 result = (int)wxMenuItem_GetDefaultMarginWidth();
43649 wxPyEndAllowThreads(__tstate);
43650 if (PyErr_Occurred()) SWIG_fail;
43651 }
43652 resultobj = SWIG_From_int(static_cast< int >(result));
43653 return resultobj;
43654 fail:
43655 return NULL;
43656 }
43657
43658
43659 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43660 PyObject *resultobj = 0;
43661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43662 bool result;
43663 void *argp1 = 0 ;
43664 int res1 = 0 ;
43665 PyObject *swig_obj[1] ;
43666
43667 if (!args) SWIG_fail;
43668 swig_obj[0] = args;
43669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43670 if (!SWIG_IsOK(res1)) {
43671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43672 }
43673 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43674 {
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 {
43681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43682 }
43683 return resultobj;
43684 fail:
43685 return NULL;
43686 }
43687
43688
43689 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43690 PyObject *resultobj = 0;
43691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43692 bool arg2 = (bool) true ;
43693 void *argp1 = 0 ;
43694 int res1 = 0 ;
43695 bool val2 ;
43696 int ecode2 = 0 ;
43697 PyObject * obj0 = 0 ;
43698 PyObject * obj1 = 0 ;
43699 char * kwnames[] = {
43700 (char *) "self",(char *) "ownerDrawn", NULL
43701 };
43702
43703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43705 if (!SWIG_IsOK(res1)) {
43706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43707 }
43708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43709 if (obj1) {
43710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43711 if (!SWIG_IsOK(ecode2)) {
43712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43713 }
43714 arg2 = static_cast< bool >(val2);
43715 }
43716 {
43717 PyThreadState* __tstate = wxPyBeginAllowThreads();
43718 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43719 wxPyEndAllowThreads(__tstate);
43720 if (PyErr_Occurred()) SWIG_fail;
43721 }
43722 resultobj = SWIG_Py_Void();
43723 return resultobj;
43724 fail:
43725 return NULL;
43726 }
43727
43728
43729 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43730 PyObject *resultobj = 0;
43731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43732 void *argp1 = 0 ;
43733 int res1 = 0 ;
43734 PyObject *swig_obj[1] ;
43735
43736 if (!args) SWIG_fail;
43737 swig_obj[0] = args;
43738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43739 if (!SWIG_IsOK(res1)) {
43740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43741 }
43742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 wxMenuItem_ResetOwnerDrawn(arg1);
43746 wxPyEndAllowThreads(__tstate);
43747 if (PyErr_Occurred()) SWIG_fail;
43748 }
43749 resultobj = SWIG_Py_Void();
43750 return resultobj;
43751 fail:
43752 return NULL;
43753 }
43754
43755
43756 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43757 PyObject *obj;
43758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43759 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43760 return SWIG_Py_Void();
43761 }
43762
43763 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43764 return SWIG_Python_InitShadowInstance(args);
43765 }
43766
43767 SWIGINTERN int ControlNameStr_set(PyObject *) {
43768 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43769 return 1;
43770 }
43771
43772
43773 SWIGINTERN PyObject *ControlNameStr_get(void) {
43774 PyObject *pyobj = 0;
43775
43776 {
43777 #if wxUSE_UNICODE
43778 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43779 #else
43780 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43781 #endif
43782 }
43783 return pyobj;
43784 }
43785
43786
43787 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43788 PyObject *resultobj = 0;
43789 wxWindow *arg1 = (wxWindow *) 0 ;
43790 int arg2 = (int) -1 ;
43791 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43792 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43793 wxSize const &arg4_defvalue = wxDefaultSize ;
43794 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43795 long arg5 = (long) 0 ;
43796 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43797 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43798 wxString const &arg7_defvalue = wxPyControlNameStr ;
43799 wxString *arg7 = (wxString *) &arg7_defvalue ;
43800 wxControl *result = 0 ;
43801 void *argp1 = 0 ;
43802 int res1 = 0 ;
43803 int val2 ;
43804 int ecode2 = 0 ;
43805 wxPoint temp3 ;
43806 wxSize temp4 ;
43807 long val5 ;
43808 int ecode5 = 0 ;
43809 void *argp6 = 0 ;
43810 int res6 = 0 ;
43811 bool temp7 = false ;
43812 PyObject * obj0 = 0 ;
43813 PyObject * obj1 = 0 ;
43814 PyObject * obj2 = 0 ;
43815 PyObject * obj3 = 0 ;
43816 PyObject * obj4 = 0 ;
43817 PyObject * obj5 = 0 ;
43818 PyObject * obj6 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43827 }
43828 arg1 = reinterpret_cast< wxWindow * >(argp1);
43829 if (obj1) {
43830 ecode2 = SWIG_AsVal_int(obj1, &val2);
43831 if (!SWIG_IsOK(ecode2)) {
43832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43833 }
43834 arg2 = static_cast< int >(val2);
43835 }
43836 if (obj2) {
43837 {
43838 arg3 = &temp3;
43839 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43840 }
43841 }
43842 if (obj3) {
43843 {
43844 arg4 = &temp4;
43845 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43846 }
43847 }
43848 if (obj4) {
43849 ecode5 = SWIG_AsVal_long(obj4, &val5);
43850 if (!SWIG_IsOK(ecode5)) {
43851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43852 }
43853 arg5 = static_cast< long >(val5);
43854 }
43855 if (obj5) {
43856 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43857 if (!SWIG_IsOK(res6)) {
43858 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43859 }
43860 if (!argp6) {
43861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43862 }
43863 arg6 = reinterpret_cast< wxValidator * >(argp6);
43864 }
43865 if (obj6) {
43866 {
43867 arg7 = wxString_in_helper(obj6);
43868 if (arg7 == NULL) SWIG_fail;
43869 temp7 = true;
43870 }
43871 }
43872 {
43873 if (!wxPyCheckForApp()) SWIG_fail;
43874 PyThreadState* __tstate = wxPyBeginAllowThreads();
43875 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43876 wxPyEndAllowThreads(__tstate);
43877 if (PyErr_Occurred()) SWIG_fail;
43878 }
43879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43880 {
43881 if (temp7)
43882 delete arg7;
43883 }
43884 return resultobj;
43885 fail:
43886 {
43887 if (temp7)
43888 delete arg7;
43889 }
43890 return NULL;
43891 }
43892
43893
43894 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43895 PyObject *resultobj = 0;
43896 wxControl *result = 0 ;
43897
43898 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43899 {
43900 if (!wxPyCheckForApp()) SWIG_fail;
43901 PyThreadState* __tstate = wxPyBeginAllowThreads();
43902 result = (wxControl *)new wxControl();
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43907 return resultobj;
43908 fail:
43909 return NULL;
43910 }
43911
43912
43913 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43914 PyObject *resultobj = 0;
43915 wxControl *arg1 = (wxControl *) 0 ;
43916 wxWindow *arg2 = (wxWindow *) 0 ;
43917 int arg3 = (int) -1 ;
43918 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43919 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43920 wxSize const &arg5_defvalue = wxDefaultSize ;
43921 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43922 long arg6 = (long) 0 ;
43923 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43924 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43925 wxString const &arg8_defvalue = wxPyControlNameStr ;
43926 wxString *arg8 = (wxString *) &arg8_defvalue ;
43927 bool result;
43928 void *argp1 = 0 ;
43929 int res1 = 0 ;
43930 void *argp2 = 0 ;
43931 int res2 = 0 ;
43932 int val3 ;
43933 int ecode3 = 0 ;
43934 wxPoint temp4 ;
43935 wxSize temp5 ;
43936 long val6 ;
43937 int ecode6 = 0 ;
43938 void *argp7 = 0 ;
43939 int res7 = 0 ;
43940 bool temp8 = false ;
43941 PyObject * obj0 = 0 ;
43942 PyObject * obj1 = 0 ;
43943 PyObject * obj2 = 0 ;
43944 PyObject * obj3 = 0 ;
43945 PyObject * obj4 = 0 ;
43946 PyObject * obj5 = 0 ;
43947 PyObject * obj6 = 0 ;
43948 PyObject * obj7 = 0 ;
43949 char * kwnames[] = {
43950 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43951 };
43952
43953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43955 if (!SWIG_IsOK(res1)) {
43956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43957 }
43958 arg1 = reinterpret_cast< wxControl * >(argp1);
43959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43960 if (!SWIG_IsOK(res2)) {
43961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43962 }
43963 arg2 = reinterpret_cast< wxWindow * >(argp2);
43964 if (obj2) {
43965 ecode3 = SWIG_AsVal_int(obj2, &val3);
43966 if (!SWIG_IsOK(ecode3)) {
43967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43968 }
43969 arg3 = static_cast< int >(val3);
43970 }
43971 if (obj3) {
43972 {
43973 arg4 = &temp4;
43974 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43975 }
43976 }
43977 if (obj4) {
43978 {
43979 arg5 = &temp5;
43980 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43981 }
43982 }
43983 if (obj5) {
43984 ecode6 = SWIG_AsVal_long(obj5, &val6);
43985 if (!SWIG_IsOK(ecode6)) {
43986 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43987 }
43988 arg6 = static_cast< long >(val6);
43989 }
43990 if (obj6) {
43991 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43992 if (!SWIG_IsOK(res7)) {
43993 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43994 }
43995 if (!argp7) {
43996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43997 }
43998 arg7 = reinterpret_cast< wxValidator * >(argp7);
43999 }
44000 if (obj7) {
44001 {
44002 arg8 = wxString_in_helper(obj7);
44003 if (arg8 == NULL) SWIG_fail;
44004 temp8 = true;
44005 }
44006 }
44007 {
44008 PyThreadState* __tstate = wxPyBeginAllowThreads();
44009 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44010 wxPyEndAllowThreads(__tstate);
44011 if (PyErr_Occurred()) SWIG_fail;
44012 }
44013 {
44014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44015 }
44016 {
44017 if (temp8)
44018 delete arg8;
44019 }
44020 return resultobj;
44021 fail:
44022 {
44023 if (temp8)
44024 delete arg8;
44025 }
44026 return NULL;
44027 }
44028
44029
44030 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44031 PyObject *resultobj = 0;
44032 wxControl *arg1 = (wxControl *) 0 ;
44033 int result;
44034 void *argp1 = 0 ;
44035 int res1 = 0 ;
44036 PyObject *swig_obj[1] ;
44037
44038 if (!args) SWIG_fail;
44039 swig_obj[0] = args;
44040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44041 if (!SWIG_IsOK(res1)) {
44042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44043 }
44044 arg1 = reinterpret_cast< wxControl * >(argp1);
44045 {
44046 PyThreadState* __tstate = wxPyBeginAllowThreads();
44047 result = (int)((wxControl const *)arg1)->GetAlignment();
44048 wxPyEndAllowThreads(__tstate);
44049 if (PyErr_Occurred()) SWIG_fail;
44050 }
44051 resultobj = SWIG_From_int(static_cast< int >(result));
44052 return resultobj;
44053 fail:
44054 return NULL;
44055 }
44056
44057
44058 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44059 PyObject *resultobj = 0;
44060 wxString *arg1 = 0 ;
44061 wxString result;
44062 bool temp1 = false ;
44063
44064 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44065 {
44066 arg1 = wxString_in_helper(swig_obj[0]);
44067 if (arg1 == NULL) SWIG_fail;
44068 temp1 = true;
44069 }
44070 {
44071 PyThreadState* __tstate = wxPyBeginAllowThreads();
44072 result = wxControl::GetLabelText((wxString const &)*arg1);
44073 wxPyEndAllowThreads(__tstate);
44074 if (PyErr_Occurred()) SWIG_fail;
44075 }
44076 {
44077 #if wxUSE_UNICODE
44078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44079 #else
44080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44081 #endif
44082 }
44083 {
44084 if (temp1)
44085 delete arg1;
44086 }
44087 return resultobj;
44088 fail:
44089 {
44090 if (temp1)
44091 delete arg1;
44092 }
44093 return NULL;
44094 }
44095
44096
44097 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44098 PyObject *resultobj = 0;
44099 wxControl *arg1 = (wxControl *) 0 ;
44100 wxString result;
44101 void *argp1 = 0 ;
44102 int res1 = 0 ;
44103
44104 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44106 if (!SWIG_IsOK(res1)) {
44107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44108 }
44109 arg1 = reinterpret_cast< wxControl * >(argp1);
44110 {
44111 PyThreadState* __tstate = wxPyBeginAllowThreads();
44112 result = ((wxControl const *)arg1)->GetLabelText();
44113 wxPyEndAllowThreads(__tstate);
44114 if (PyErr_Occurred()) SWIG_fail;
44115 }
44116 {
44117 #if wxUSE_UNICODE
44118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44119 #else
44120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44121 #endif
44122 }
44123 return resultobj;
44124 fail:
44125 return NULL;
44126 }
44127
44128
44129 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *self, PyObject *args) {
44130 int argc;
44131 PyObject *argv[2];
44132
44133 if (!(argc = SWIG_Python_UnpackTuple(args,"Control_GetLabelText",0,1,argv))) SWIG_fail;
44134 --argc;
44135 if (argc == 1) {
44136 int _v = 0;
44137 {
44138 {
44139 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
44140 }
44141 }
44142 if (!_v) goto check_1;
44143 return _wrap_Control_GetLabelText__SWIG_0(self, argc, argv);
44144 }
44145 check_1:
44146
44147 if (argc == 1) {
44148 return _wrap_Control_GetLabelText__SWIG_1(self, argc, argv);
44149 }
44150
44151 fail:
44152 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Control_GetLabelText'");
44153 return NULL;
44154 }
44155
44156
44157 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44158 PyObject *resultobj = 0;
44159 wxControl *arg1 = (wxControl *) 0 ;
44160 wxCommandEvent *arg2 = 0 ;
44161 void *argp1 = 0 ;
44162 int res1 = 0 ;
44163 void *argp2 = 0 ;
44164 int res2 = 0 ;
44165 PyObject * obj0 = 0 ;
44166 PyObject * obj1 = 0 ;
44167 char * kwnames[] = {
44168 (char *) "self",(char *) "event", NULL
44169 };
44170
44171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44173 if (!SWIG_IsOK(res1)) {
44174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44175 }
44176 arg1 = reinterpret_cast< wxControl * >(argp1);
44177 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44178 if (!SWIG_IsOK(res2)) {
44179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44180 }
44181 if (!argp2) {
44182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44183 }
44184 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44185 {
44186 PyThreadState* __tstate = wxPyBeginAllowThreads();
44187 (arg1)->Command(*arg2);
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 resultobj = SWIG_Py_Void();
44192 return resultobj;
44193 fail:
44194 return NULL;
44195 }
44196
44197
44198 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44199 PyObject *resultobj = 0;
44200 wxControl *arg1 = (wxControl *) 0 ;
44201 wxString result;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 PyObject *swig_obj[1] ;
44205
44206 if (!args) SWIG_fail;
44207 swig_obj[0] = args;
44208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44209 if (!SWIG_IsOK(res1)) {
44210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44211 }
44212 arg1 = reinterpret_cast< wxControl * >(argp1);
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 result = (arg1)->GetLabel();
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 {
44220 #if wxUSE_UNICODE
44221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44222 #else
44223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44224 #endif
44225 }
44226 return resultobj;
44227 fail:
44228 return NULL;
44229 }
44230
44231
44232 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44233 PyObject *resultobj = 0;
44234 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44235 SwigValueWrapper<wxVisualAttributes > result;
44236 int val1 ;
44237 int ecode1 = 0 ;
44238 PyObject * obj0 = 0 ;
44239 char * kwnames[] = {
44240 (char *) "variant", NULL
44241 };
44242
44243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44244 if (obj0) {
44245 ecode1 = SWIG_AsVal_int(obj0, &val1);
44246 if (!SWIG_IsOK(ecode1)) {
44247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44248 }
44249 arg1 = static_cast< wxWindowVariant >(val1);
44250 }
44251 {
44252 if (!wxPyCheckForApp()) SWIG_fail;
44253 PyThreadState* __tstate = wxPyBeginAllowThreads();
44254 result = wxControl::GetClassDefaultAttributes(arg1);
44255 wxPyEndAllowThreads(__tstate);
44256 if (PyErr_Occurred()) SWIG_fail;
44257 }
44258 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44259 return resultobj;
44260 fail:
44261 return NULL;
44262 }
44263
44264
44265 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44266 PyObject *obj;
44267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44268 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44269 return SWIG_Py_Void();
44270 }
44271
44272 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44273 return SWIG_Python_InitShadowInstance(args);
44274 }
44275
44276 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44277 PyObject *resultobj = 0;
44278 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44279 wxString *arg2 = 0 ;
44280 PyObject *arg3 = (PyObject *) NULL ;
44281 int result;
44282 void *argp1 = 0 ;
44283 int res1 = 0 ;
44284 bool temp2 = false ;
44285 PyObject * obj0 = 0 ;
44286 PyObject * obj1 = 0 ;
44287 PyObject * obj2 = 0 ;
44288 char * kwnames[] = {
44289 (char *) "self",(char *) "item",(char *) "clientData", NULL
44290 };
44291
44292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44294 if (!SWIG_IsOK(res1)) {
44295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44296 }
44297 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44298 {
44299 arg2 = wxString_in_helper(obj1);
44300 if (arg2 == NULL) SWIG_fail;
44301 temp2 = true;
44302 }
44303 if (obj2) {
44304 arg3 = obj2;
44305 }
44306 {
44307 PyThreadState* __tstate = wxPyBeginAllowThreads();
44308 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44309 wxPyEndAllowThreads(__tstate);
44310 if (PyErr_Occurred()) SWIG_fail;
44311 }
44312 resultobj = SWIG_From_int(static_cast< int >(result));
44313 {
44314 if (temp2)
44315 delete arg2;
44316 }
44317 return resultobj;
44318 fail:
44319 {
44320 if (temp2)
44321 delete arg2;
44322 }
44323 return NULL;
44324 }
44325
44326
44327 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44328 PyObject *resultobj = 0;
44329 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44330 wxArrayString *arg2 = 0 ;
44331 void *argp1 = 0 ;
44332 int res1 = 0 ;
44333 bool temp2 = false ;
44334 PyObject * obj0 = 0 ;
44335 PyObject * obj1 = 0 ;
44336 char * kwnames[] = {
44337 (char *) "self",(char *) "strings", NULL
44338 };
44339
44340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44342 if (!SWIG_IsOK(res1)) {
44343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44344 }
44345 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44346 {
44347 if (! PySequence_Check(obj1)) {
44348 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44349 SWIG_fail;
44350 }
44351 arg2 = new wxArrayString;
44352 temp2 = true;
44353 int i, len=PySequence_Length(obj1);
44354 for (i=0; i<len; i++) {
44355 PyObject* item = PySequence_GetItem(obj1, i);
44356 wxString* s = wxString_in_helper(item);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 arg2->Add(*s);
44359 delete s;
44360 Py_DECREF(item);
44361 }
44362 }
44363 {
44364 PyThreadState* __tstate = wxPyBeginAllowThreads();
44365 (arg1)->Append((wxArrayString const &)*arg2);
44366 wxPyEndAllowThreads(__tstate);
44367 if (PyErr_Occurred()) SWIG_fail;
44368 }
44369 resultobj = SWIG_Py_Void();
44370 {
44371 if (temp2) delete arg2;
44372 }
44373 return resultobj;
44374 fail:
44375 {
44376 if (temp2) delete arg2;
44377 }
44378 return NULL;
44379 }
44380
44381
44382 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44383 PyObject *resultobj = 0;
44384 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44385 wxString *arg2 = 0 ;
44386 unsigned int arg3 ;
44387 PyObject *arg4 = (PyObject *) NULL ;
44388 int result;
44389 void *argp1 = 0 ;
44390 int res1 = 0 ;
44391 bool temp2 = false ;
44392 unsigned int val3 ;
44393 int ecode3 = 0 ;
44394 PyObject * obj0 = 0 ;
44395 PyObject * obj1 = 0 ;
44396 PyObject * obj2 = 0 ;
44397 PyObject * obj3 = 0 ;
44398 char * kwnames[] = {
44399 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44400 };
44401
44402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44404 if (!SWIG_IsOK(res1)) {
44405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44406 }
44407 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44408 {
44409 arg2 = wxString_in_helper(obj1);
44410 if (arg2 == NULL) SWIG_fail;
44411 temp2 = true;
44412 }
44413 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44414 if (!SWIG_IsOK(ecode3)) {
44415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44416 }
44417 arg3 = static_cast< unsigned int >(val3);
44418 if (obj3) {
44419 arg4 = obj3;
44420 }
44421 {
44422 PyThreadState* __tstate = wxPyBeginAllowThreads();
44423 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44424 wxPyEndAllowThreads(__tstate);
44425 if (PyErr_Occurred()) SWIG_fail;
44426 }
44427 resultobj = SWIG_From_int(static_cast< int >(result));
44428 {
44429 if (temp2)
44430 delete arg2;
44431 }
44432 return resultobj;
44433 fail:
44434 {
44435 if (temp2)
44436 delete arg2;
44437 }
44438 return NULL;
44439 }
44440
44441
44442 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44443 PyObject *resultobj = 0;
44444 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44445 void *argp1 = 0 ;
44446 int res1 = 0 ;
44447 PyObject *swig_obj[1] ;
44448
44449 if (!args) SWIG_fail;
44450 swig_obj[0] = args;
44451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44452 if (!SWIG_IsOK(res1)) {
44453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44454 }
44455 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44456 {
44457 PyThreadState* __tstate = wxPyBeginAllowThreads();
44458 (arg1)->Clear();
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 resultobj = SWIG_Py_Void();
44463 return resultobj;
44464 fail:
44465 return NULL;
44466 }
44467
44468
44469 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44470 PyObject *resultobj = 0;
44471 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44472 unsigned int arg2 ;
44473 void *argp1 = 0 ;
44474 int res1 = 0 ;
44475 unsigned int val2 ;
44476 int ecode2 = 0 ;
44477 PyObject * obj0 = 0 ;
44478 PyObject * obj1 = 0 ;
44479 char * kwnames[] = {
44480 (char *) "self",(char *) "n", NULL
44481 };
44482
44483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44485 if (!SWIG_IsOK(res1)) {
44486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44487 }
44488 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44489 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44490 if (!SWIG_IsOK(ecode2)) {
44491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44492 }
44493 arg2 = static_cast< unsigned int >(val2);
44494 {
44495 PyThreadState* __tstate = wxPyBeginAllowThreads();
44496 (arg1)->Delete(arg2);
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 resultobj = SWIG_Py_Void();
44501 return resultobj;
44502 fail:
44503 return NULL;
44504 }
44505
44506
44507 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44508 PyObject *resultobj = 0;
44509 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44510 unsigned int arg2 ;
44511 PyObject *result = 0 ;
44512 void *argp1 = 0 ;
44513 int res1 = 0 ;
44514 unsigned int val2 ;
44515 int ecode2 = 0 ;
44516 PyObject * obj0 = 0 ;
44517 PyObject * obj1 = 0 ;
44518 char * kwnames[] = {
44519 (char *) "self",(char *) "n", NULL
44520 };
44521
44522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44526 }
44527 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44528 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44529 if (!SWIG_IsOK(ecode2)) {
44530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44531 }
44532 arg2 = static_cast< unsigned int >(val2);
44533 {
44534 PyThreadState* __tstate = wxPyBeginAllowThreads();
44535 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44536 wxPyEndAllowThreads(__tstate);
44537 if (PyErr_Occurred()) SWIG_fail;
44538 }
44539 resultobj = result;
44540 return resultobj;
44541 fail:
44542 return NULL;
44543 }
44544
44545
44546 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44547 PyObject *resultobj = 0;
44548 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44549 unsigned int arg2 ;
44550 PyObject *arg3 = (PyObject *) 0 ;
44551 void *argp1 = 0 ;
44552 int res1 = 0 ;
44553 unsigned int val2 ;
44554 int ecode2 = 0 ;
44555 PyObject * obj0 = 0 ;
44556 PyObject * obj1 = 0 ;
44557 PyObject * obj2 = 0 ;
44558 char * kwnames[] = {
44559 (char *) "self",(char *) "n",(char *) "clientData", NULL
44560 };
44561
44562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44564 if (!SWIG_IsOK(res1)) {
44565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44566 }
44567 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44568 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44569 if (!SWIG_IsOK(ecode2)) {
44570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44571 }
44572 arg2 = static_cast< unsigned int >(val2);
44573 arg3 = obj2;
44574 {
44575 PyThreadState* __tstate = wxPyBeginAllowThreads();
44576 wxItemContainer_SetClientData(arg1,arg2,arg3);
44577 wxPyEndAllowThreads(__tstate);
44578 if (PyErr_Occurred()) SWIG_fail;
44579 }
44580 resultobj = SWIG_Py_Void();
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44588 PyObject *resultobj = 0;
44589 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44590 unsigned int result;
44591 void *argp1 = 0 ;
44592 int res1 = 0 ;
44593 PyObject *swig_obj[1] ;
44594
44595 if (!args) SWIG_fail;
44596 swig_obj[0] = args;
44597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44598 if (!SWIG_IsOK(res1)) {
44599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44600 }
44601 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44602 {
44603 PyThreadState* __tstate = wxPyBeginAllowThreads();
44604 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44605 wxPyEndAllowThreads(__tstate);
44606 if (PyErr_Occurred()) SWIG_fail;
44607 }
44608 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44609 return resultobj;
44610 fail:
44611 return NULL;
44612 }
44613
44614
44615 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44616 PyObject *resultobj = 0;
44617 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44618 bool result;
44619 void *argp1 = 0 ;
44620 int res1 = 0 ;
44621 PyObject *swig_obj[1] ;
44622
44623 if (!args) SWIG_fail;
44624 swig_obj[0] = args;
44625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44626 if (!SWIG_IsOK(res1)) {
44627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44628 }
44629 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44630 {
44631 PyThreadState* __tstate = wxPyBeginAllowThreads();
44632 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44633 wxPyEndAllowThreads(__tstate);
44634 if (PyErr_Occurred()) SWIG_fail;
44635 }
44636 {
44637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44638 }
44639 return resultobj;
44640 fail:
44641 return NULL;
44642 }
44643
44644
44645 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44646 PyObject *resultobj = 0;
44647 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44648 unsigned int arg2 ;
44649 wxString result;
44650 void *argp1 = 0 ;
44651 int res1 = 0 ;
44652 unsigned int val2 ;
44653 int ecode2 = 0 ;
44654 PyObject * obj0 = 0 ;
44655 PyObject * obj1 = 0 ;
44656 char * kwnames[] = {
44657 (char *) "self",(char *) "n", NULL
44658 };
44659
44660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44662 if (!SWIG_IsOK(res1)) {
44663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44664 }
44665 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44666 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44667 if (!SWIG_IsOK(ecode2)) {
44668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44669 }
44670 arg2 = static_cast< unsigned int >(val2);
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 {
44678 #if wxUSE_UNICODE
44679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44680 #else
44681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44682 #endif
44683 }
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44691 PyObject *resultobj = 0;
44692 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44693 wxArrayString result;
44694 void *argp1 = 0 ;
44695 int res1 = 0 ;
44696 PyObject *swig_obj[1] ;
44697
44698 if (!args) SWIG_fail;
44699 swig_obj[0] = args;
44700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44701 if (!SWIG_IsOK(res1)) {
44702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44703 }
44704 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = ((wxItemContainer const *)arg1)->GetStrings();
44708 wxPyEndAllowThreads(__tstate);
44709 if (PyErr_Occurred()) SWIG_fail;
44710 }
44711 {
44712 resultobj = wxArrayString2PyList_helper(result);
44713 }
44714 return resultobj;
44715 fail:
44716 return NULL;
44717 }
44718
44719
44720 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44721 PyObject *resultobj = 0;
44722 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44723 unsigned int arg2 ;
44724 wxString *arg3 = 0 ;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 unsigned int val2 ;
44728 int ecode2 = 0 ;
44729 bool temp3 = false ;
44730 PyObject * obj0 = 0 ;
44731 PyObject * obj1 = 0 ;
44732 PyObject * obj2 = 0 ;
44733 char * kwnames[] = {
44734 (char *) "self",(char *) "n",(char *) "s", NULL
44735 };
44736
44737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44739 if (!SWIG_IsOK(res1)) {
44740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44741 }
44742 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44743 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44744 if (!SWIG_IsOK(ecode2)) {
44745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44746 }
44747 arg2 = static_cast< unsigned int >(val2);
44748 {
44749 arg3 = wxString_in_helper(obj2);
44750 if (arg3 == NULL) SWIG_fail;
44751 temp3 = true;
44752 }
44753 {
44754 PyThreadState* __tstate = wxPyBeginAllowThreads();
44755 (arg1)->SetString(arg2,(wxString const &)*arg3);
44756 wxPyEndAllowThreads(__tstate);
44757 if (PyErr_Occurred()) SWIG_fail;
44758 }
44759 resultobj = SWIG_Py_Void();
44760 {
44761 if (temp3)
44762 delete arg3;
44763 }
44764 return resultobj;
44765 fail:
44766 {
44767 if (temp3)
44768 delete arg3;
44769 }
44770 return NULL;
44771 }
44772
44773
44774 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44775 PyObject *resultobj = 0;
44776 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44777 wxString *arg2 = 0 ;
44778 int result;
44779 void *argp1 = 0 ;
44780 int res1 = 0 ;
44781 bool temp2 = false ;
44782 PyObject * obj0 = 0 ;
44783 PyObject * obj1 = 0 ;
44784 char * kwnames[] = {
44785 (char *) "self",(char *) "s", NULL
44786 };
44787
44788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44790 if (!SWIG_IsOK(res1)) {
44791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44792 }
44793 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44794 {
44795 arg2 = wxString_in_helper(obj1);
44796 if (arg2 == NULL) SWIG_fail;
44797 temp2 = true;
44798 }
44799 {
44800 PyThreadState* __tstate = wxPyBeginAllowThreads();
44801 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44802 wxPyEndAllowThreads(__tstate);
44803 if (PyErr_Occurred()) SWIG_fail;
44804 }
44805 resultobj = SWIG_From_int(static_cast< int >(result));
44806 {
44807 if (temp2)
44808 delete arg2;
44809 }
44810 return resultobj;
44811 fail:
44812 {
44813 if (temp2)
44814 delete arg2;
44815 }
44816 return NULL;
44817 }
44818
44819
44820 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44821 PyObject *resultobj = 0;
44822 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44823 int arg2 ;
44824 void *argp1 = 0 ;
44825 int res1 = 0 ;
44826 int val2 ;
44827 int ecode2 = 0 ;
44828 PyObject * obj0 = 0 ;
44829 PyObject * obj1 = 0 ;
44830 char * kwnames[] = {
44831 (char *) "self",(char *) "n", NULL
44832 };
44833
44834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44836 if (!SWIG_IsOK(res1)) {
44837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44838 }
44839 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44840 ecode2 = SWIG_AsVal_int(obj1, &val2);
44841 if (!SWIG_IsOK(ecode2)) {
44842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44843 }
44844 arg2 = static_cast< int >(val2);
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 (arg1)->SetSelection(arg2);
44848 wxPyEndAllowThreads(__tstate);
44849 if (PyErr_Occurred()) SWIG_fail;
44850 }
44851 resultobj = SWIG_Py_Void();
44852 return resultobj;
44853 fail:
44854 return NULL;
44855 }
44856
44857
44858 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44859 PyObject *resultobj = 0;
44860 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44861 int result;
44862 void *argp1 = 0 ;
44863 int res1 = 0 ;
44864 PyObject *swig_obj[1] ;
44865
44866 if (!args) SWIG_fail;
44867 swig_obj[0] = args;
44868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44869 if (!SWIG_IsOK(res1)) {
44870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44871 }
44872 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44873 {
44874 PyThreadState* __tstate = wxPyBeginAllowThreads();
44875 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44876 wxPyEndAllowThreads(__tstate);
44877 if (PyErr_Occurred()) SWIG_fail;
44878 }
44879 resultobj = SWIG_From_int(static_cast< int >(result));
44880 return resultobj;
44881 fail:
44882 return NULL;
44883 }
44884
44885
44886 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44887 PyObject *resultobj = 0;
44888 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44889 wxString *arg2 = 0 ;
44890 bool result;
44891 void *argp1 = 0 ;
44892 int res1 = 0 ;
44893 bool temp2 = false ;
44894 PyObject * obj0 = 0 ;
44895 PyObject * obj1 = 0 ;
44896 char * kwnames[] = {
44897 (char *) "self",(char *) "s", NULL
44898 };
44899
44900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44902 if (!SWIG_IsOK(res1)) {
44903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44904 }
44905 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44906 {
44907 arg2 = wxString_in_helper(obj1);
44908 if (arg2 == NULL) SWIG_fail;
44909 temp2 = true;
44910 }
44911 {
44912 PyThreadState* __tstate = wxPyBeginAllowThreads();
44913 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44914 wxPyEndAllowThreads(__tstate);
44915 if (PyErr_Occurred()) SWIG_fail;
44916 }
44917 {
44918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44919 }
44920 {
44921 if (temp2)
44922 delete arg2;
44923 }
44924 return resultobj;
44925 fail:
44926 {
44927 if (temp2)
44928 delete arg2;
44929 }
44930 return NULL;
44931 }
44932
44933
44934 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44935 PyObject *resultobj = 0;
44936 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44937 wxString result;
44938 void *argp1 = 0 ;
44939 int res1 = 0 ;
44940 PyObject *swig_obj[1] ;
44941
44942 if (!args) SWIG_fail;
44943 swig_obj[0] = args;
44944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44945 if (!SWIG_IsOK(res1)) {
44946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44947 }
44948 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44949 {
44950 PyThreadState* __tstate = wxPyBeginAllowThreads();
44951 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44952 wxPyEndAllowThreads(__tstate);
44953 if (PyErr_Occurred()) SWIG_fail;
44954 }
44955 {
44956 #if wxUSE_UNICODE
44957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44958 #else
44959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44960 #endif
44961 }
44962 return resultobj;
44963 fail:
44964 return NULL;
44965 }
44966
44967
44968 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44969 PyObject *resultobj = 0;
44970 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44971 int arg2 ;
44972 void *argp1 = 0 ;
44973 int res1 = 0 ;
44974 int val2 ;
44975 int ecode2 = 0 ;
44976 PyObject * obj0 = 0 ;
44977 PyObject * obj1 = 0 ;
44978 char * kwnames[] = {
44979 (char *) "self",(char *) "n", NULL
44980 };
44981
44982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44984 if (!SWIG_IsOK(res1)) {
44985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44986 }
44987 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44988 ecode2 = SWIG_AsVal_int(obj1, &val2);
44989 if (!SWIG_IsOK(ecode2)) {
44990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44991 }
44992 arg2 = static_cast< int >(val2);
44993 {
44994 PyThreadState* __tstate = wxPyBeginAllowThreads();
44995 (arg1)->Select(arg2);
44996 wxPyEndAllowThreads(__tstate);
44997 if (PyErr_Occurred()) SWIG_fail;
44998 }
44999 resultobj = SWIG_Py_Void();
45000 return resultobj;
45001 fail:
45002 return NULL;
45003 }
45004
45005
45006 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45007 PyObject *obj;
45008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45009 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45010 return SWIG_Py_Void();
45011 }
45012
45013 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45014 PyObject *obj;
45015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45016 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45017 return SWIG_Py_Void();
45018 }
45019
45020 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45021 PyObject *resultobj = 0;
45022 wxSizerItem *result = 0 ;
45023
45024 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45025 {
45026 PyThreadState* __tstate = wxPyBeginAllowThreads();
45027 result = (wxSizerItem *)new wxSizerItem();
45028 wxPyEndAllowThreads(__tstate);
45029 if (PyErr_Occurred()) SWIG_fail;
45030 }
45031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45032 return resultobj;
45033 fail:
45034 return NULL;
45035 }
45036
45037
45038 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45039 PyObject *resultobj = 0;
45040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45041 void *argp1 = 0 ;
45042 int res1 = 0 ;
45043 PyObject *swig_obj[1] ;
45044
45045 if (!args) SWIG_fail;
45046 swig_obj[0] = args;
45047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45048 if (!SWIG_IsOK(res1)) {
45049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45050 }
45051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45052 {
45053 PyThreadState* __tstate = wxPyBeginAllowThreads();
45054 delete arg1;
45055
45056 wxPyEndAllowThreads(__tstate);
45057 if (PyErr_Occurred()) SWIG_fail;
45058 }
45059 resultobj = SWIG_Py_Void();
45060 return resultobj;
45061 fail:
45062 return NULL;
45063 }
45064
45065
45066 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45067 PyObject *resultobj = 0;
45068 wxWindow *arg1 = (wxWindow *) 0 ;
45069 int arg2 ;
45070 int arg3 ;
45071 int arg4 ;
45072 PyObject *arg5 = (PyObject *) NULL ;
45073 wxSizerItem *result = 0 ;
45074 void *argp1 = 0 ;
45075 int res1 = 0 ;
45076 int val2 ;
45077 int ecode2 = 0 ;
45078 int val3 ;
45079 int ecode3 = 0 ;
45080 int val4 ;
45081 int ecode4 = 0 ;
45082 PyObject * obj0 = 0 ;
45083 PyObject * obj1 = 0 ;
45084 PyObject * obj2 = 0 ;
45085 PyObject * obj3 = 0 ;
45086 PyObject * obj4 = 0 ;
45087 char * kwnames[] = {
45088 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45089 };
45090
45091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45093 if (!SWIG_IsOK(res1)) {
45094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45095 }
45096 arg1 = reinterpret_cast< wxWindow * >(argp1);
45097 ecode2 = SWIG_AsVal_int(obj1, &val2);
45098 if (!SWIG_IsOK(ecode2)) {
45099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45100 }
45101 arg2 = static_cast< int >(val2);
45102 ecode3 = SWIG_AsVal_int(obj2, &val3);
45103 if (!SWIG_IsOK(ecode3)) {
45104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45105 }
45106 arg3 = static_cast< int >(val3);
45107 ecode4 = SWIG_AsVal_int(obj3, &val4);
45108 if (!SWIG_IsOK(ecode4)) {
45109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45110 }
45111 arg4 = static_cast< int >(val4);
45112 if (obj4) {
45113 arg5 = obj4;
45114 }
45115 {
45116 PyThreadState* __tstate = wxPyBeginAllowThreads();
45117 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45118 wxPyEndAllowThreads(__tstate);
45119 if (PyErr_Occurred()) SWIG_fail;
45120 }
45121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45122 return resultobj;
45123 fail:
45124 return NULL;
45125 }
45126
45127
45128 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45129 PyObject *resultobj = 0;
45130 int arg1 ;
45131 int arg2 ;
45132 int arg3 ;
45133 int arg4 ;
45134 int arg5 ;
45135 PyObject *arg6 = (PyObject *) NULL ;
45136 wxSizerItem *result = 0 ;
45137 int val1 ;
45138 int ecode1 = 0 ;
45139 int val2 ;
45140 int ecode2 = 0 ;
45141 int val3 ;
45142 int ecode3 = 0 ;
45143 int val4 ;
45144 int ecode4 = 0 ;
45145 int val5 ;
45146 int ecode5 = 0 ;
45147 PyObject * obj0 = 0 ;
45148 PyObject * obj1 = 0 ;
45149 PyObject * obj2 = 0 ;
45150 PyObject * obj3 = 0 ;
45151 PyObject * obj4 = 0 ;
45152 PyObject * obj5 = 0 ;
45153 char * kwnames[] = {
45154 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45155 };
45156
45157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45158 ecode1 = SWIG_AsVal_int(obj0, &val1);
45159 if (!SWIG_IsOK(ecode1)) {
45160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45161 }
45162 arg1 = static_cast< int >(val1);
45163 ecode2 = SWIG_AsVal_int(obj1, &val2);
45164 if (!SWIG_IsOK(ecode2)) {
45165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45166 }
45167 arg2 = static_cast< int >(val2);
45168 ecode3 = SWIG_AsVal_int(obj2, &val3);
45169 if (!SWIG_IsOK(ecode3)) {
45170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45171 }
45172 arg3 = static_cast< int >(val3);
45173 ecode4 = SWIG_AsVal_int(obj3, &val4);
45174 if (!SWIG_IsOK(ecode4)) {
45175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45176 }
45177 arg4 = static_cast< int >(val4);
45178 ecode5 = SWIG_AsVal_int(obj4, &val5);
45179 if (!SWIG_IsOK(ecode5)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45181 }
45182 arg5 = static_cast< int >(val5);
45183 if (obj5) {
45184 arg6 = obj5;
45185 }
45186 {
45187 PyThreadState* __tstate = wxPyBeginAllowThreads();
45188 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45189 wxPyEndAllowThreads(__tstate);
45190 if (PyErr_Occurred()) SWIG_fail;
45191 }
45192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45193 return resultobj;
45194 fail:
45195 return NULL;
45196 }
45197
45198
45199 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45200 PyObject *resultobj = 0;
45201 wxSizer *arg1 = (wxSizer *) 0 ;
45202 int arg2 ;
45203 int arg3 ;
45204 int arg4 ;
45205 PyObject *arg5 = (PyObject *) NULL ;
45206 wxSizerItem *result = 0 ;
45207 int res1 = 0 ;
45208 int val2 ;
45209 int ecode2 = 0 ;
45210 int val3 ;
45211 int ecode3 = 0 ;
45212 int val4 ;
45213 int ecode4 = 0 ;
45214 PyObject * obj0 = 0 ;
45215 PyObject * obj1 = 0 ;
45216 PyObject * obj2 = 0 ;
45217 PyObject * obj3 = 0 ;
45218 PyObject * obj4 = 0 ;
45219 char * kwnames[] = {
45220 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45221 };
45222
45223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45224 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45227 }
45228 ecode2 = SWIG_AsVal_int(obj1, &val2);
45229 if (!SWIG_IsOK(ecode2)) {
45230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45231 }
45232 arg2 = static_cast< int >(val2);
45233 ecode3 = SWIG_AsVal_int(obj2, &val3);
45234 if (!SWIG_IsOK(ecode3)) {
45235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45236 }
45237 arg3 = static_cast< int >(val3);
45238 ecode4 = SWIG_AsVal_int(obj3, &val4);
45239 if (!SWIG_IsOK(ecode4)) {
45240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45241 }
45242 arg4 = static_cast< int >(val4);
45243 if (obj4) {
45244 arg5 = obj4;
45245 }
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45260 PyObject *resultobj = 0;
45261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45262 void *argp1 = 0 ;
45263 int res1 = 0 ;
45264 PyObject *swig_obj[1] ;
45265
45266 if (!args) SWIG_fail;
45267 swig_obj[0] = args;
45268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45269 if (!SWIG_IsOK(res1)) {
45270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45271 }
45272 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45273 {
45274 PyThreadState* __tstate = wxPyBeginAllowThreads();
45275 (arg1)->DeleteWindows();
45276 wxPyEndAllowThreads(__tstate);
45277 if (PyErr_Occurred()) SWIG_fail;
45278 }
45279 resultobj = SWIG_Py_Void();
45280 return resultobj;
45281 fail:
45282 return NULL;
45283 }
45284
45285
45286 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45287 PyObject *resultobj = 0;
45288 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45289 void *argp1 = 0 ;
45290 int res1 = 0 ;
45291 PyObject *swig_obj[1] ;
45292
45293 if (!args) SWIG_fail;
45294 swig_obj[0] = args;
45295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45296 if (!SWIG_IsOK(res1)) {
45297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45298 }
45299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 (arg1)->DetachSizer();
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 resultobj = SWIG_Py_Void();
45307 return resultobj;
45308 fail:
45309 return NULL;
45310 }
45311
45312
45313 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45314 PyObject *resultobj = 0;
45315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45316 wxSize result;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 PyObject *swig_obj[1] ;
45320
45321 if (!args) SWIG_fail;
45322 swig_obj[0] = args;
45323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45326 }
45327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 result = (arg1)->GetSize();
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45342 PyObject *resultobj = 0;
45343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45344 wxSize result;
45345 void *argp1 = 0 ;
45346 int res1 = 0 ;
45347 PyObject *swig_obj[1] ;
45348
45349 if (!args) SWIG_fail;
45350 swig_obj[0] = args;
45351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45352 if (!SWIG_IsOK(res1)) {
45353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45354 }
45355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 result = (arg1)->CalcMin();
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45363 return resultobj;
45364 fail:
45365 return NULL;
45366 }
45367
45368
45369 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45370 PyObject *resultobj = 0;
45371 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45372 wxPoint *arg2 = 0 ;
45373 wxSize *arg3 = 0 ;
45374 void *argp1 = 0 ;
45375 int res1 = 0 ;
45376 wxPoint temp2 ;
45377 wxSize temp3 ;
45378 PyObject * obj0 = 0 ;
45379 PyObject * obj1 = 0 ;
45380 PyObject * obj2 = 0 ;
45381 char * kwnames[] = {
45382 (char *) "self",(char *) "pos",(char *) "size", NULL
45383 };
45384
45385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45387 if (!SWIG_IsOK(res1)) {
45388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45389 }
45390 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45391 {
45392 arg2 = &temp2;
45393 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45394 }
45395 {
45396 arg3 = &temp3;
45397 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45398 }
45399 {
45400 PyThreadState* __tstate = wxPyBeginAllowThreads();
45401 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45402 wxPyEndAllowThreads(__tstate);
45403 if (PyErr_Occurred()) SWIG_fail;
45404 }
45405 resultobj = SWIG_Py_Void();
45406 return resultobj;
45407 fail:
45408 return NULL;
45409 }
45410
45411
45412 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45413 PyObject *resultobj = 0;
45414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45415 wxSize result;
45416 void *argp1 = 0 ;
45417 int res1 = 0 ;
45418 PyObject *swig_obj[1] ;
45419
45420 if (!args) SWIG_fail;
45421 swig_obj[0] = args;
45422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45423 if (!SWIG_IsOK(res1)) {
45424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45425 }
45426 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45427 {
45428 PyThreadState* __tstate = wxPyBeginAllowThreads();
45429 result = (arg1)->GetMinSize();
45430 wxPyEndAllowThreads(__tstate);
45431 if (PyErr_Occurred()) SWIG_fail;
45432 }
45433 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45434 return resultobj;
45435 fail:
45436 return NULL;
45437 }
45438
45439
45440 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45441 PyObject *resultobj = 0;
45442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45443 wxSize result;
45444 void *argp1 = 0 ;
45445 int res1 = 0 ;
45446 PyObject *swig_obj[1] ;
45447
45448 if (!args) SWIG_fail;
45449 swig_obj[0] = args;
45450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45451 if (!SWIG_IsOK(res1)) {
45452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45453 }
45454 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45455 {
45456 PyThreadState* __tstate = wxPyBeginAllowThreads();
45457 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45458 wxPyEndAllowThreads(__tstate);
45459 if (PyErr_Occurred()) SWIG_fail;
45460 }
45461 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45462 return resultobj;
45463 fail:
45464 return NULL;
45465 }
45466
45467
45468 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45469 PyObject *resultobj = 0;
45470 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45471 int arg2 ;
45472 int arg3 ;
45473 void *argp1 = 0 ;
45474 int res1 = 0 ;
45475 int val2 ;
45476 int ecode2 = 0 ;
45477 int val3 ;
45478 int ecode3 = 0 ;
45479 PyObject * obj0 = 0 ;
45480 PyObject * obj1 = 0 ;
45481 PyObject * obj2 = 0 ;
45482 char * kwnames[] = {
45483 (char *) "self",(char *) "x",(char *) "y", NULL
45484 };
45485
45486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45488 if (!SWIG_IsOK(res1)) {
45489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45490 }
45491 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45492 ecode2 = SWIG_AsVal_int(obj1, &val2);
45493 if (!SWIG_IsOK(ecode2)) {
45494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45495 }
45496 arg2 = static_cast< int >(val2);
45497 ecode3 = SWIG_AsVal_int(obj2, &val3);
45498 if (!SWIG_IsOK(ecode3)) {
45499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45500 }
45501 arg3 = static_cast< int >(val3);
45502 {
45503 PyThreadState* __tstate = wxPyBeginAllowThreads();
45504 (arg1)->SetInitSize(arg2,arg3);
45505 wxPyEndAllowThreads(__tstate);
45506 if (PyErr_Occurred()) SWIG_fail;
45507 }
45508 resultobj = SWIG_Py_Void();
45509 return resultobj;
45510 fail:
45511 return NULL;
45512 }
45513
45514
45515 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45516 PyObject *resultobj = 0;
45517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45518 int arg2 ;
45519 int arg3 ;
45520 void *argp1 = 0 ;
45521 int res1 = 0 ;
45522 int val2 ;
45523 int ecode2 = 0 ;
45524 int val3 ;
45525 int ecode3 = 0 ;
45526 PyObject * obj0 = 0 ;
45527 PyObject * obj1 = 0 ;
45528 PyObject * obj2 = 0 ;
45529 char * kwnames[] = {
45530 (char *) "self",(char *) "width",(char *) "height", NULL
45531 };
45532
45533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45535 if (!SWIG_IsOK(res1)) {
45536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45537 }
45538 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45539 ecode2 = SWIG_AsVal_int(obj1, &val2);
45540 if (!SWIG_IsOK(ecode2)) {
45541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45542 }
45543 arg2 = static_cast< int >(val2);
45544 ecode3 = SWIG_AsVal_int(obj2, &val3);
45545 if (!SWIG_IsOK(ecode3)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45547 }
45548 arg3 = static_cast< int >(val3);
45549 {
45550 PyThreadState* __tstate = wxPyBeginAllowThreads();
45551 (arg1)->SetRatio(arg2,arg3);
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 resultobj = SWIG_Py_Void();
45556 return resultobj;
45557 fail:
45558 return NULL;
45559 }
45560
45561
45562 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45563 PyObject *resultobj = 0;
45564 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45565 wxSize *arg2 = 0 ;
45566 void *argp1 = 0 ;
45567 int res1 = 0 ;
45568 wxSize temp2 ;
45569 PyObject * obj0 = 0 ;
45570 PyObject * obj1 = 0 ;
45571 char * kwnames[] = {
45572 (char *) "self",(char *) "size", NULL
45573 };
45574
45575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45577 if (!SWIG_IsOK(res1)) {
45578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45579 }
45580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45581 {
45582 arg2 = &temp2;
45583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45584 }
45585 {
45586 PyThreadState* __tstate = wxPyBeginAllowThreads();
45587 (arg1)->SetRatio((wxSize const &)*arg2);
45588 wxPyEndAllowThreads(__tstate);
45589 if (PyErr_Occurred()) SWIG_fail;
45590 }
45591 resultobj = SWIG_Py_Void();
45592 return resultobj;
45593 fail:
45594 return NULL;
45595 }
45596
45597
45598 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45599 PyObject *resultobj = 0;
45600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45601 float arg2 ;
45602 void *argp1 = 0 ;
45603 int res1 = 0 ;
45604 float val2 ;
45605 int ecode2 = 0 ;
45606 PyObject * obj0 = 0 ;
45607 PyObject * obj1 = 0 ;
45608 char * kwnames[] = {
45609 (char *) "self",(char *) "ratio", NULL
45610 };
45611
45612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45614 if (!SWIG_IsOK(res1)) {
45615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45616 }
45617 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45618 ecode2 = SWIG_AsVal_float(obj1, &val2);
45619 if (!SWIG_IsOK(ecode2)) {
45620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45621 }
45622 arg2 = static_cast< float >(val2);
45623 {
45624 PyThreadState* __tstate = wxPyBeginAllowThreads();
45625 (arg1)->SetRatio(arg2);
45626 wxPyEndAllowThreads(__tstate);
45627 if (PyErr_Occurred()) SWIG_fail;
45628 }
45629 resultobj = SWIG_Py_Void();
45630 return resultobj;
45631 fail:
45632 return NULL;
45633 }
45634
45635
45636 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45637 PyObject *resultobj = 0;
45638 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45639 float result;
45640 void *argp1 = 0 ;
45641 int res1 = 0 ;
45642 PyObject *swig_obj[1] ;
45643
45644 if (!args) SWIG_fail;
45645 swig_obj[0] = args;
45646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45647 if (!SWIG_IsOK(res1)) {
45648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45649 }
45650 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45651 {
45652 PyThreadState* __tstate = wxPyBeginAllowThreads();
45653 result = (float)(arg1)->GetRatio();
45654 wxPyEndAllowThreads(__tstate);
45655 if (PyErr_Occurred()) SWIG_fail;
45656 }
45657 resultobj = SWIG_From_float(static_cast< float >(result));
45658 return resultobj;
45659 fail:
45660 return NULL;
45661 }
45662
45663
45664 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45665 PyObject *resultobj = 0;
45666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45667 wxRect result;
45668 void *argp1 = 0 ;
45669 int res1 = 0 ;
45670 PyObject *swig_obj[1] ;
45671
45672 if (!args) SWIG_fail;
45673 swig_obj[0] = args;
45674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45675 if (!SWIG_IsOK(res1)) {
45676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45677 }
45678 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45679 {
45680 PyThreadState* __tstate = wxPyBeginAllowThreads();
45681 result = (arg1)->GetRect();
45682 wxPyEndAllowThreads(__tstate);
45683 if (PyErr_Occurred()) SWIG_fail;
45684 }
45685 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45686 return resultobj;
45687 fail:
45688 return NULL;
45689 }
45690
45691
45692 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45693 PyObject *resultobj = 0;
45694 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45695 bool result;
45696 void *argp1 = 0 ;
45697 int res1 = 0 ;
45698 PyObject *swig_obj[1] ;
45699
45700 if (!args) SWIG_fail;
45701 swig_obj[0] = args;
45702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45703 if (!SWIG_IsOK(res1)) {
45704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45705 }
45706 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 result = (bool)(arg1)->IsWindow();
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 {
45714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45715 }
45716 return resultobj;
45717 fail:
45718 return NULL;
45719 }
45720
45721
45722 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45723 PyObject *resultobj = 0;
45724 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45725 bool result;
45726 void *argp1 = 0 ;
45727 int res1 = 0 ;
45728 PyObject *swig_obj[1] ;
45729
45730 if (!args) SWIG_fail;
45731 swig_obj[0] = args;
45732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45733 if (!SWIG_IsOK(res1)) {
45734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45735 }
45736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 result = (bool)(arg1)->IsSizer();
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 {
45744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45745 }
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45753 PyObject *resultobj = 0;
45754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45755 bool result;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 PyObject *swig_obj[1] ;
45759
45760 if (!args) SWIG_fail;
45761 swig_obj[0] = args;
45762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45763 if (!SWIG_IsOK(res1)) {
45764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45765 }
45766 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45767 {
45768 PyThreadState* __tstate = wxPyBeginAllowThreads();
45769 result = (bool)(arg1)->IsSpacer();
45770 wxPyEndAllowThreads(__tstate);
45771 if (PyErr_Occurred()) SWIG_fail;
45772 }
45773 {
45774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45775 }
45776 return resultobj;
45777 fail:
45778 return NULL;
45779 }
45780
45781
45782 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45783 PyObject *resultobj = 0;
45784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45785 int arg2 ;
45786 void *argp1 = 0 ;
45787 int res1 = 0 ;
45788 int val2 ;
45789 int ecode2 = 0 ;
45790 PyObject * obj0 = 0 ;
45791 PyObject * obj1 = 0 ;
45792 char * kwnames[] = {
45793 (char *) "self",(char *) "proportion", NULL
45794 };
45795
45796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 ecode2 = SWIG_AsVal_int(obj1, &val2);
45803 if (!SWIG_IsOK(ecode2)) {
45804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45805 }
45806 arg2 = static_cast< int >(val2);
45807 {
45808 PyThreadState* __tstate = wxPyBeginAllowThreads();
45809 (arg1)->SetProportion(arg2);
45810 wxPyEndAllowThreads(__tstate);
45811 if (PyErr_Occurred()) SWIG_fail;
45812 }
45813 resultobj = SWIG_Py_Void();
45814 return resultobj;
45815 fail:
45816 return NULL;
45817 }
45818
45819
45820 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45821 PyObject *resultobj = 0;
45822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45823 int result;
45824 void *argp1 = 0 ;
45825 int res1 = 0 ;
45826 PyObject *swig_obj[1] ;
45827
45828 if (!args) SWIG_fail;
45829 swig_obj[0] = args;
45830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45833 }
45834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45835 {
45836 PyThreadState* __tstate = wxPyBeginAllowThreads();
45837 result = (int)(arg1)->GetProportion();
45838 wxPyEndAllowThreads(__tstate);
45839 if (PyErr_Occurred()) SWIG_fail;
45840 }
45841 resultobj = SWIG_From_int(static_cast< int >(result));
45842 return resultobj;
45843 fail:
45844 return NULL;
45845 }
45846
45847
45848 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45849 PyObject *resultobj = 0;
45850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45851 int arg2 ;
45852 void *argp1 = 0 ;
45853 int res1 = 0 ;
45854 int val2 ;
45855 int ecode2 = 0 ;
45856 PyObject * obj0 = 0 ;
45857 PyObject * obj1 = 0 ;
45858 char * kwnames[] = {
45859 (char *) "self",(char *) "flag", NULL
45860 };
45861
45862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45864 if (!SWIG_IsOK(res1)) {
45865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45866 }
45867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45868 ecode2 = SWIG_AsVal_int(obj1, &val2);
45869 if (!SWIG_IsOK(ecode2)) {
45870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45871 }
45872 arg2 = static_cast< int >(val2);
45873 {
45874 PyThreadState* __tstate = wxPyBeginAllowThreads();
45875 (arg1)->SetFlag(arg2);
45876 wxPyEndAllowThreads(__tstate);
45877 if (PyErr_Occurred()) SWIG_fail;
45878 }
45879 resultobj = SWIG_Py_Void();
45880 return resultobj;
45881 fail:
45882 return NULL;
45883 }
45884
45885
45886 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45887 PyObject *resultobj = 0;
45888 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45889 int result;
45890 void *argp1 = 0 ;
45891 int res1 = 0 ;
45892 PyObject *swig_obj[1] ;
45893
45894 if (!args) SWIG_fail;
45895 swig_obj[0] = args;
45896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45897 if (!SWIG_IsOK(res1)) {
45898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45899 }
45900 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45901 {
45902 PyThreadState* __tstate = wxPyBeginAllowThreads();
45903 result = (int)(arg1)->GetFlag();
45904 wxPyEndAllowThreads(__tstate);
45905 if (PyErr_Occurred()) SWIG_fail;
45906 }
45907 resultobj = SWIG_From_int(static_cast< int >(result));
45908 return resultobj;
45909 fail:
45910 return NULL;
45911 }
45912
45913
45914 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45915 PyObject *resultobj = 0;
45916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45917 int arg2 ;
45918 void *argp1 = 0 ;
45919 int res1 = 0 ;
45920 int val2 ;
45921 int ecode2 = 0 ;
45922 PyObject * obj0 = 0 ;
45923 PyObject * obj1 = 0 ;
45924 char * kwnames[] = {
45925 (char *) "self",(char *) "border", NULL
45926 };
45927
45928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45930 if (!SWIG_IsOK(res1)) {
45931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45932 }
45933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45934 ecode2 = SWIG_AsVal_int(obj1, &val2);
45935 if (!SWIG_IsOK(ecode2)) {
45936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45937 }
45938 arg2 = static_cast< int >(val2);
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 (arg1)->SetBorder(arg2);
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 resultobj = SWIG_Py_Void();
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45953 PyObject *resultobj = 0;
45954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45955 int result;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 PyObject *swig_obj[1] ;
45959
45960 if (!args) SWIG_fail;
45961 swig_obj[0] = args;
45962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45963 if (!SWIG_IsOK(res1)) {
45964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45965 }
45966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45967 {
45968 PyThreadState* __tstate = wxPyBeginAllowThreads();
45969 result = (int)(arg1)->GetBorder();
45970 wxPyEndAllowThreads(__tstate);
45971 if (PyErr_Occurred()) SWIG_fail;
45972 }
45973 resultobj = SWIG_From_int(static_cast< int >(result));
45974 return resultobj;
45975 fail:
45976 return NULL;
45977 }
45978
45979
45980 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45981 PyObject *resultobj = 0;
45982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45983 wxWindow *result = 0 ;
45984 void *argp1 = 0 ;
45985 int res1 = 0 ;
45986 PyObject *swig_obj[1] ;
45987
45988 if (!args) SWIG_fail;
45989 swig_obj[0] = args;
45990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45991 if (!SWIG_IsOK(res1)) {
45992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45993 }
45994 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = (wxWindow *)(arg1)->GetWindow();
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 {
46002 resultobj = wxPyMake_wxObject(result, 0);
46003 }
46004 return resultobj;
46005 fail:
46006 return NULL;
46007 }
46008
46009
46010 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46011 PyObject *resultobj = 0;
46012 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46013 wxWindow *arg2 = (wxWindow *) 0 ;
46014 void *argp1 = 0 ;
46015 int res1 = 0 ;
46016 void *argp2 = 0 ;
46017 int res2 = 0 ;
46018 PyObject * obj0 = 0 ;
46019 PyObject * obj1 = 0 ;
46020 char * kwnames[] = {
46021 (char *) "self",(char *) "window", NULL
46022 };
46023
46024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46026 if (!SWIG_IsOK(res1)) {
46027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46028 }
46029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46031 if (!SWIG_IsOK(res2)) {
46032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46033 }
46034 arg2 = reinterpret_cast< wxWindow * >(argp2);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 (arg1)->SetWindow(arg2);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_Py_Void();
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 wxSizer *result = 0 ;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject *swig_obj[1] ;
46055
46056 if (!args) SWIG_fail;
46057 swig_obj[0] = args;
46058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (wxSizer *)(arg1)->GetSizer();
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 {
46070 resultobj = wxPyMake_wxObject(result, (bool)0);
46071 }
46072 return resultobj;
46073 fail:
46074 return NULL;
46075 }
46076
46077
46078 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46079 PyObject *resultobj = 0;
46080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46081 wxSizer *arg2 = (wxSizer *) 0 ;
46082 void *argp1 = 0 ;
46083 int res1 = 0 ;
46084 int res2 = 0 ;
46085 PyObject * obj0 = 0 ;
46086 PyObject * obj1 = 0 ;
46087 char * kwnames[] = {
46088 (char *) "self",(char *) "sizer", NULL
46089 };
46090
46091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46097 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46098 if (!SWIG_IsOK(res2)) {
46099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46100 }
46101 {
46102 PyThreadState* __tstate = wxPyBeginAllowThreads();
46103 (arg1)->SetSizer(arg2);
46104 wxPyEndAllowThreads(__tstate);
46105 if (PyErr_Occurred()) SWIG_fail;
46106 }
46107 resultobj = SWIG_Py_Void();
46108 return resultobj;
46109 fail:
46110 return NULL;
46111 }
46112
46113
46114 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46115 PyObject *resultobj = 0;
46116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46117 wxSize *result = 0 ;
46118 void *argp1 = 0 ;
46119 int res1 = 0 ;
46120 PyObject *swig_obj[1] ;
46121
46122 if (!args) SWIG_fail;
46123 swig_obj[0] = args;
46124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46125 if (!SWIG_IsOK(res1)) {
46126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46127 }
46128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46129 {
46130 PyThreadState* __tstate = wxPyBeginAllowThreads();
46131 {
46132 wxSize const &_result_ref = (arg1)->GetSpacer();
46133 result = (wxSize *) &_result_ref;
46134 }
46135 wxPyEndAllowThreads(__tstate);
46136 if (PyErr_Occurred()) SWIG_fail;
46137 }
46138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46139 return resultobj;
46140 fail:
46141 return NULL;
46142 }
46143
46144
46145 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46146 PyObject *resultobj = 0;
46147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46148 wxSize *arg2 = 0 ;
46149 void *argp1 = 0 ;
46150 int res1 = 0 ;
46151 wxSize temp2 ;
46152 PyObject * obj0 = 0 ;
46153 PyObject * obj1 = 0 ;
46154 char * kwnames[] = {
46155 (char *) "self",(char *) "size", NULL
46156 };
46157
46158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46160 if (!SWIG_IsOK(res1)) {
46161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46162 }
46163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46164 {
46165 arg2 = &temp2;
46166 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46167 }
46168 {
46169 PyThreadState* __tstate = wxPyBeginAllowThreads();
46170 (arg1)->SetSpacer((wxSize const &)*arg2);
46171 wxPyEndAllowThreads(__tstate);
46172 if (PyErr_Occurred()) SWIG_fail;
46173 }
46174 resultobj = SWIG_Py_Void();
46175 return resultobj;
46176 fail:
46177 return NULL;
46178 }
46179
46180
46181 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46182 PyObject *resultobj = 0;
46183 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46184 bool arg2 ;
46185 void *argp1 = 0 ;
46186 int res1 = 0 ;
46187 bool val2 ;
46188 int ecode2 = 0 ;
46189 PyObject * obj0 = 0 ;
46190 PyObject * obj1 = 0 ;
46191 char * kwnames[] = {
46192 (char *) "self",(char *) "show", NULL
46193 };
46194
46195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46197 if (!SWIG_IsOK(res1)) {
46198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46199 }
46200 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46201 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46202 if (!SWIG_IsOK(ecode2)) {
46203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46204 }
46205 arg2 = static_cast< bool >(val2);
46206 {
46207 PyThreadState* __tstate = wxPyBeginAllowThreads();
46208 (arg1)->Show(arg2);
46209 wxPyEndAllowThreads(__tstate);
46210 if (PyErr_Occurred()) SWIG_fail;
46211 }
46212 resultobj = SWIG_Py_Void();
46213 return resultobj;
46214 fail:
46215 return NULL;
46216 }
46217
46218
46219 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46220 PyObject *resultobj = 0;
46221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46222 bool result;
46223 void *argp1 = 0 ;
46224 int res1 = 0 ;
46225 PyObject *swig_obj[1] ;
46226
46227 if (!args) SWIG_fail;
46228 swig_obj[0] = args;
46229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46232 }
46233 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 result = (bool)(arg1)->IsShown();
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 {
46241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46242 }
46243 return resultobj;
46244 fail:
46245 return NULL;
46246 }
46247
46248
46249 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46250 PyObject *resultobj = 0;
46251 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46252 wxPoint result;
46253 void *argp1 = 0 ;
46254 int res1 = 0 ;
46255 PyObject *swig_obj[1] ;
46256
46257 if (!args) SWIG_fail;
46258 swig_obj[0] = args;
46259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46260 if (!SWIG_IsOK(res1)) {
46261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46262 }
46263 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46264 {
46265 PyThreadState* __tstate = wxPyBeginAllowThreads();
46266 result = (arg1)->GetPosition();
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46278 PyObject *resultobj = 0;
46279 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46280 PyObject *result = 0 ;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 PyObject *swig_obj[1] ;
46284
46285 if (!args) SWIG_fail;
46286 swig_obj[0] = args;
46287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46290 }
46291 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46292 {
46293 PyThreadState* __tstate = wxPyBeginAllowThreads();
46294 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46295 wxPyEndAllowThreads(__tstate);
46296 if (PyErr_Occurred()) SWIG_fail;
46297 }
46298 resultobj = result;
46299 return resultobj;
46300 fail:
46301 return NULL;
46302 }
46303
46304
46305 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46306 PyObject *resultobj = 0;
46307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46308 PyObject *arg2 = (PyObject *) 0 ;
46309 void *argp1 = 0 ;
46310 int res1 = 0 ;
46311 PyObject * obj0 = 0 ;
46312 PyObject * obj1 = 0 ;
46313 char * kwnames[] = {
46314 (char *) "self",(char *) "userData", NULL
46315 };
46316
46317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46319 if (!SWIG_IsOK(res1)) {
46320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46321 }
46322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46323 arg2 = obj1;
46324 {
46325 PyThreadState* __tstate = wxPyBeginAllowThreads();
46326 wxSizerItem_SetUserData(arg1,arg2);
46327 wxPyEndAllowThreads(__tstate);
46328 if (PyErr_Occurred()) SWIG_fail;
46329 }
46330 resultobj = SWIG_Py_Void();
46331 return resultobj;
46332 fail:
46333 return NULL;
46334 }
46335
46336
46337 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46338 PyObject *obj;
46339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46340 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46341 return SWIG_Py_Void();
46342 }
46343
46344 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46345 return SWIG_Python_InitShadowInstance(args);
46346 }
46347
46348 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46349 PyObject *resultobj = 0;
46350 wxSizer *arg1 = (wxSizer *) 0 ;
46351 void *argp1 = 0 ;
46352 int res1 = 0 ;
46353 PyObject *swig_obj[1] ;
46354
46355 if (!args) SWIG_fail;
46356 swig_obj[0] = args;
46357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46358 if (!SWIG_IsOK(res1)) {
46359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46360 }
46361 arg1 = reinterpret_cast< wxSizer * >(argp1);
46362 {
46363 PyThreadState* __tstate = wxPyBeginAllowThreads();
46364 delete arg1;
46365
46366 wxPyEndAllowThreads(__tstate);
46367 if (PyErr_Occurred()) SWIG_fail;
46368 }
46369 resultobj = SWIG_Py_Void();
46370 return resultobj;
46371 fail:
46372 return NULL;
46373 }
46374
46375
46376 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46377 PyObject *resultobj = 0;
46378 wxSizer *arg1 = (wxSizer *) 0 ;
46379 PyObject *arg2 = (PyObject *) 0 ;
46380 void *argp1 = 0 ;
46381 int res1 = 0 ;
46382 PyObject * obj0 = 0 ;
46383 PyObject * obj1 = 0 ;
46384 char * kwnames[] = {
46385 (char *) "self",(char *) "_self", NULL
46386 };
46387
46388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46390 if (!SWIG_IsOK(res1)) {
46391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46392 }
46393 arg1 = reinterpret_cast< wxSizer * >(argp1);
46394 arg2 = obj1;
46395 {
46396 PyThreadState* __tstate = wxPyBeginAllowThreads();
46397 wxSizer__setOORInfo(arg1,arg2);
46398 wxPyEndAllowThreads(__tstate);
46399 if (PyErr_Occurred()) SWIG_fail;
46400 }
46401 resultobj = SWIG_Py_Void();
46402 return resultobj;
46403 fail:
46404 return NULL;
46405 }
46406
46407
46408 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46409 PyObject *resultobj = 0;
46410 wxSizer *arg1 = (wxSizer *) 0 ;
46411 PyObject *arg2 = (PyObject *) 0 ;
46412 int arg3 = (int) 0 ;
46413 int arg4 = (int) 0 ;
46414 int arg5 = (int) 0 ;
46415 PyObject *arg6 = (PyObject *) NULL ;
46416 wxSizerItem *result = 0 ;
46417 void *argp1 = 0 ;
46418 int res1 = 0 ;
46419 int val3 ;
46420 int ecode3 = 0 ;
46421 int val4 ;
46422 int ecode4 = 0 ;
46423 int val5 ;
46424 int ecode5 = 0 ;
46425 PyObject * obj0 = 0 ;
46426 PyObject * obj1 = 0 ;
46427 PyObject * obj2 = 0 ;
46428 PyObject * obj3 = 0 ;
46429 PyObject * obj4 = 0 ;
46430 PyObject * obj5 = 0 ;
46431 char * kwnames[] = {
46432 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46433 };
46434
46435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46437 if (!SWIG_IsOK(res1)) {
46438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46439 }
46440 arg1 = reinterpret_cast< wxSizer * >(argp1);
46441 arg2 = obj1;
46442 if (obj2) {
46443 ecode3 = SWIG_AsVal_int(obj2, &val3);
46444 if (!SWIG_IsOK(ecode3)) {
46445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46446 }
46447 arg3 = static_cast< int >(val3);
46448 }
46449 if (obj3) {
46450 ecode4 = SWIG_AsVal_int(obj3, &val4);
46451 if (!SWIG_IsOK(ecode4)) {
46452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46453 }
46454 arg4 = static_cast< int >(val4);
46455 }
46456 if (obj4) {
46457 ecode5 = SWIG_AsVal_int(obj4, &val5);
46458 if (!SWIG_IsOK(ecode5)) {
46459 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46460 }
46461 arg5 = static_cast< int >(val5);
46462 }
46463 if (obj5) {
46464 arg6 = obj5;
46465 }
46466 {
46467 PyThreadState* __tstate = wxPyBeginAllowThreads();
46468 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46469 wxPyEndAllowThreads(__tstate);
46470 if (PyErr_Occurred()) SWIG_fail;
46471 }
46472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46473 return resultobj;
46474 fail:
46475 return NULL;
46476 }
46477
46478
46479 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46480 PyObject *resultobj = 0;
46481 wxSizer *arg1 = (wxSizer *) 0 ;
46482 int arg2 ;
46483 PyObject *arg3 = (PyObject *) 0 ;
46484 int arg4 = (int) 0 ;
46485 int arg5 = (int) 0 ;
46486 int arg6 = (int) 0 ;
46487 PyObject *arg7 = (PyObject *) NULL ;
46488 wxSizerItem *result = 0 ;
46489 void *argp1 = 0 ;
46490 int res1 = 0 ;
46491 int val2 ;
46492 int ecode2 = 0 ;
46493 int val4 ;
46494 int ecode4 = 0 ;
46495 int val5 ;
46496 int ecode5 = 0 ;
46497 int val6 ;
46498 int ecode6 = 0 ;
46499 PyObject * obj0 = 0 ;
46500 PyObject * obj1 = 0 ;
46501 PyObject * obj2 = 0 ;
46502 PyObject * obj3 = 0 ;
46503 PyObject * obj4 = 0 ;
46504 PyObject * obj5 = 0 ;
46505 PyObject * obj6 = 0 ;
46506 char * kwnames[] = {
46507 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46508 };
46509
46510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46512 if (!SWIG_IsOK(res1)) {
46513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46514 }
46515 arg1 = reinterpret_cast< wxSizer * >(argp1);
46516 ecode2 = SWIG_AsVal_int(obj1, &val2);
46517 if (!SWIG_IsOK(ecode2)) {
46518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46519 }
46520 arg2 = static_cast< int >(val2);
46521 arg3 = obj2;
46522 if (obj3) {
46523 ecode4 = SWIG_AsVal_int(obj3, &val4);
46524 if (!SWIG_IsOK(ecode4)) {
46525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46526 }
46527 arg4 = static_cast< int >(val4);
46528 }
46529 if (obj4) {
46530 ecode5 = SWIG_AsVal_int(obj4, &val5);
46531 if (!SWIG_IsOK(ecode5)) {
46532 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46533 }
46534 arg5 = static_cast< int >(val5);
46535 }
46536 if (obj5) {
46537 ecode6 = SWIG_AsVal_int(obj5, &val6);
46538 if (!SWIG_IsOK(ecode6)) {
46539 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46540 }
46541 arg6 = static_cast< int >(val6);
46542 }
46543 if (obj6) {
46544 arg7 = obj6;
46545 }
46546 {
46547 PyThreadState* __tstate = wxPyBeginAllowThreads();
46548 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46549 wxPyEndAllowThreads(__tstate);
46550 if (PyErr_Occurred()) SWIG_fail;
46551 }
46552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46553 return resultobj;
46554 fail:
46555 return NULL;
46556 }
46557
46558
46559 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46560 PyObject *resultobj = 0;
46561 wxSizer *arg1 = (wxSizer *) 0 ;
46562 PyObject *arg2 = (PyObject *) 0 ;
46563 int arg3 = (int) 0 ;
46564 int arg4 = (int) 0 ;
46565 int arg5 = (int) 0 ;
46566 PyObject *arg6 = (PyObject *) NULL ;
46567 wxSizerItem *result = 0 ;
46568 void *argp1 = 0 ;
46569 int res1 = 0 ;
46570 int val3 ;
46571 int ecode3 = 0 ;
46572 int val4 ;
46573 int ecode4 = 0 ;
46574 int val5 ;
46575 int ecode5 = 0 ;
46576 PyObject * obj0 = 0 ;
46577 PyObject * obj1 = 0 ;
46578 PyObject * obj2 = 0 ;
46579 PyObject * obj3 = 0 ;
46580 PyObject * obj4 = 0 ;
46581 PyObject * obj5 = 0 ;
46582 char * kwnames[] = {
46583 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46584 };
46585
46586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46590 }
46591 arg1 = reinterpret_cast< wxSizer * >(argp1);
46592 arg2 = obj1;
46593 if (obj2) {
46594 ecode3 = SWIG_AsVal_int(obj2, &val3);
46595 if (!SWIG_IsOK(ecode3)) {
46596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46597 }
46598 arg3 = static_cast< int >(val3);
46599 }
46600 if (obj3) {
46601 ecode4 = SWIG_AsVal_int(obj3, &val4);
46602 if (!SWIG_IsOK(ecode4)) {
46603 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46604 }
46605 arg4 = static_cast< int >(val4);
46606 }
46607 if (obj4) {
46608 ecode5 = SWIG_AsVal_int(obj4, &val5);
46609 if (!SWIG_IsOK(ecode5)) {
46610 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46611 }
46612 arg5 = static_cast< int >(val5);
46613 }
46614 if (obj5) {
46615 arg6 = obj5;
46616 }
46617 {
46618 PyThreadState* __tstate = wxPyBeginAllowThreads();
46619 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46620 wxPyEndAllowThreads(__tstate);
46621 if (PyErr_Occurred()) SWIG_fail;
46622 }
46623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46624 return resultobj;
46625 fail:
46626 return NULL;
46627 }
46628
46629
46630 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46631 PyObject *resultobj = 0;
46632 wxSizer *arg1 = (wxSizer *) 0 ;
46633 PyObject *arg2 = (PyObject *) 0 ;
46634 bool result;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 PyObject * obj0 = 0 ;
46638 PyObject * obj1 = 0 ;
46639 char * kwnames[] = {
46640 (char *) "self",(char *) "item", NULL
46641 };
46642
46643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46645 if (!SWIG_IsOK(res1)) {
46646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46647 }
46648 arg1 = reinterpret_cast< wxSizer * >(argp1);
46649 arg2 = obj1;
46650 {
46651 PyThreadState* __tstate = wxPyBeginAllowThreads();
46652 result = (bool)wxSizer_Remove(arg1,arg2);
46653 wxPyEndAllowThreads(__tstate);
46654 if (PyErr_Occurred()) SWIG_fail;
46655 }
46656 {
46657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46658 }
46659 return resultobj;
46660 fail:
46661 return NULL;
46662 }
46663
46664
46665 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46666 PyObject *resultobj = 0;
46667 wxSizer *arg1 = (wxSizer *) 0 ;
46668 PyObject *arg2 = (PyObject *) 0 ;
46669 bool result;
46670 void *argp1 = 0 ;
46671 int res1 = 0 ;
46672 PyObject * obj0 = 0 ;
46673 PyObject * obj1 = 0 ;
46674 char * kwnames[] = {
46675 (char *) "self",(char *) "item", NULL
46676 };
46677
46678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46680 if (!SWIG_IsOK(res1)) {
46681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46682 }
46683 arg1 = reinterpret_cast< wxSizer * >(argp1);
46684 arg2 = obj1;
46685 {
46686 PyThreadState* __tstate = wxPyBeginAllowThreads();
46687 result = (bool)wxSizer_Detach(arg1,arg2);
46688 wxPyEndAllowThreads(__tstate);
46689 if (PyErr_Occurred()) SWIG_fail;
46690 }
46691 {
46692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46693 }
46694 return resultobj;
46695 fail:
46696 return NULL;
46697 }
46698
46699
46700 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46701 PyObject *resultobj = 0;
46702 wxSizer *arg1 = (wxSizer *) 0 ;
46703 PyObject *arg2 = (PyObject *) 0 ;
46704 wxSizerItem *result = 0 ;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 PyObject * obj0 = 0 ;
46708 PyObject * obj1 = 0 ;
46709 char * kwnames[] = {
46710 (char *) "self",(char *) "item", NULL
46711 };
46712
46713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46715 if (!SWIG_IsOK(res1)) {
46716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46717 }
46718 arg1 = reinterpret_cast< wxSizer * >(argp1);
46719 arg2 = obj1;
46720 {
46721 PyThreadState* __tstate = wxPyBeginAllowThreads();
46722 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46723 wxPyEndAllowThreads(__tstate);
46724 if (PyErr_Occurred()) SWIG_fail;
46725 }
46726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46727 return resultobj;
46728 fail:
46729 return NULL;
46730 }
46731
46732
46733 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46734 PyObject *resultobj = 0;
46735 wxSizer *arg1 = (wxSizer *) 0 ;
46736 PyObject *arg2 = (PyObject *) 0 ;
46737 wxSize *arg3 = 0 ;
46738 void *argp1 = 0 ;
46739 int res1 = 0 ;
46740 wxSize temp3 ;
46741 PyObject * obj0 = 0 ;
46742 PyObject * obj1 = 0 ;
46743 PyObject * obj2 = 0 ;
46744 char * kwnames[] = {
46745 (char *) "self",(char *) "item",(char *) "size", NULL
46746 };
46747
46748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46750 if (!SWIG_IsOK(res1)) {
46751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46752 }
46753 arg1 = reinterpret_cast< wxSizer * >(argp1);
46754 arg2 = obj1;
46755 {
46756 arg3 = &temp3;
46757 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46758 }
46759 {
46760 PyThreadState* __tstate = wxPyBeginAllowThreads();
46761 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46762 wxPyEndAllowThreads(__tstate);
46763 if (PyErr_Occurred()) SWIG_fail;
46764 }
46765 resultobj = SWIG_Py_Void();
46766 return resultobj;
46767 fail:
46768 return NULL;
46769 }
46770
46771
46772 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46773 PyObject *resultobj = 0;
46774 wxSizer *arg1 = (wxSizer *) 0 ;
46775 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46776 wxSizerItem *result = 0 ;
46777 void *argp1 = 0 ;
46778 int res1 = 0 ;
46779 int res2 = 0 ;
46780 PyObject * obj0 = 0 ;
46781 PyObject * obj1 = 0 ;
46782 char * kwnames[] = {
46783 (char *) "self",(char *) "item", NULL
46784 };
46785
46786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46788 if (!SWIG_IsOK(res1)) {
46789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46790 }
46791 arg1 = reinterpret_cast< wxSizer * >(argp1);
46792 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46793 if (!SWIG_IsOK(res2)) {
46794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46795 }
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 result = (wxSizerItem *)(arg1)->Add(arg2);
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46810 PyObject *resultobj = 0;
46811 wxSizer *arg1 = (wxSizer *) 0 ;
46812 size_t arg2 ;
46813 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46814 wxSizerItem *result = 0 ;
46815 void *argp1 = 0 ;
46816 int res1 = 0 ;
46817 size_t val2 ;
46818 int ecode2 = 0 ;
46819 int res3 = 0 ;
46820 PyObject * obj0 = 0 ;
46821 PyObject * obj1 = 0 ;
46822 PyObject * obj2 = 0 ;
46823 char * kwnames[] = {
46824 (char *) "self",(char *) "index",(char *) "item", NULL
46825 };
46826
46827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46829 if (!SWIG_IsOK(res1)) {
46830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46831 }
46832 arg1 = reinterpret_cast< wxSizer * >(argp1);
46833 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46834 if (!SWIG_IsOK(ecode2)) {
46835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46836 }
46837 arg2 = static_cast< size_t >(val2);
46838 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46839 if (!SWIG_IsOK(res3)) {
46840 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46841 }
46842 {
46843 PyThreadState* __tstate = wxPyBeginAllowThreads();
46844 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46845 wxPyEndAllowThreads(__tstate);
46846 if (PyErr_Occurred()) SWIG_fail;
46847 }
46848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46849 return resultobj;
46850 fail:
46851 return NULL;
46852 }
46853
46854
46855 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46856 PyObject *resultobj = 0;
46857 wxSizer *arg1 = (wxSizer *) 0 ;
46858 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46859 wxSizerItem *result = 0 ;
46860 void *argp1 = 0 ;
46861 int res1 = 0 ;
46862 int res2 = 0 ;
46863 PyObject * obj0 = 0 ;
46864 PyObject * obj1 = 0 ;
46865 char * kwnames[] = {
46866 (char *) "self",(char *) "item", NULL
46867 };
46868
46869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46873 }
46874 arg1 = reinterpret_cast< wxSizer * >(argp1);
46875 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46876 if (!SWIG_IsOK(res2)) {
46877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46878 }
46879 {
46880 PyThreadState* __tstate = wxPyBeginAllowThreads();
46881 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46882 wxPyEndAllowThreads(__tstate);
46883 if (PyErr_Occurred()) SWIG_fail;
46884 }
46885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46886 return resultobj;
46887 fail:
46888 return NULL;
46889 }
46890
46891
46892 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46893 PyObject *resultobj = 0;
46894 wxSizer *arg1 = (wxSizer *) 0 ;
46895 int arg2 ;
46896 int arg3 ;
46897 int arg4 ;
46898 int arg5 ;
46899 void *argp1 = 0 ;
46900 int res1 = 0 ;
46901 int val2 ;
46902 int ecode2 = 0 ;
46903 int val3 ;
46904 int ecode3 = 0 ;
46905 int val4 ;
46906 int ecode4 = 0 ;
46907 int val5 ;
46908 int ecode5 = 0 ;
46909 PyObject * obj0 = 0 ;
46910 PyObject * obj1 = 0 ;
46911 PyObject * obj2 = 0 ;
46912 PyObject * obj3 = 0 ;
46913 PyObject * obj4 = 0 ;
46914 char * kwnames[] = {
46915 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46916 };
46917
46918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46920 if (!SWIG_IsOK(res1)) {
46921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46922 }
46923 arg1 = reinterpret_cast< wxSizer * >(argp1);
46924 ecode2 = SWIG_AsVal_int(obj1, &val2);
46925 if (!SWIG_IsOK(ecode2)) {
46926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46927 }
46928 arg2 = static_cast< int >(val2);
46929 ecode3 = SWIG_AsVal_int(obj2, &val3);
46930 if (!SWIG_IsOK(ecode3)) {
46931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46932 }
46933 arg3 = static_cast< int >(val3);
46934 ecode4 = SWIG_AsVal_int(obj3, &val4);
46935 if (!SWIG_IsOK(ecode4)) {
46936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46937 }
46938 arg4 = static_cast< int >(val4);
46939 ecode5 = SWIG_AsVal_int(obj4, &val5);
46940 if (!SWIG_IsOK(ecode5)) {
46941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46942 }
46943 arg5 = static_cast< int >(val5);
46944 {
46945 PyThreadState* __tstate = wxPyBeginAllowThreads();
46946 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46947 wxPyEndAllowThreads(__tstate);
46948 if (PyErr_Occurred()) SWIG_fail;
46949 }
46950 resultobj = SWIG_Py_Void();
46951 return resultobj;
46952 fail:
46953 return NULL;
46954 }
46955
46956
46957 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46958 PyObject *resultobj = 0;
46959 wxSizer *arg1 = (wxSizer *) 0 ;
46960 wxSize *arg2 = 0 ;
46961 void *argp1 = 0 ;
46962 int res1 = 0 ;
46963 wxSize temp2 ;
46964 PyObject * obj0 = 0 ;
46965 PyObject * obj1 = 0 ;
46966 char * kwnames[] = {
46967 (char *) "self",(char *) "size", NULL
46968 };
46969
46970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46972 if (!SWIG_IsOK(res1)) {
46973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46974 }
46975 arg1 = reinterpret_cast< wxSizer * >(argp1);
46976 {
46977 arg2 = &temp2;
46978 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46979 }
46980 {
46981 PyThreadState* __tstate = wxPyBeginAllowThreads();
46982 (arg1)->SetMinSize((wxSize const &)*arg2);
46983 wxPyEndAllowThreads(__tstate);
46984 if (PyErr_Occurred()) SWIG_fail;
46985 }
46986 resultobj = SWIG_Py_Void();
46987 return resultobj;
46988 fail:
46989 return NULL;
46990 }
46991
46992
46993 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46994 PyObject *resultobj = 0;
46995 wxSizer *arg1 = (wxSizer *) 0 ;
46996 wxSize result;
46997 void *argp1 = 0 ;
46998 int res1 = 0 ;
46999 PyObject *swig_obj[1] ;
47000
47001 if (!args) SWIG_fail;
47002 swig_obj[0] = args;
47003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47004 if (!SWIG_IsOK(res1)) {
47005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47006 }
47007 arg1 = reinterpret_cast< wxSizer * >(argp1);
47008 {
47009 PyThreadState* __tstate = wxPyBeginAllowThreads();
47010 result = (arg1)->GetSize();
47011 wxPyEndAllowThreads(__tstate);
47012 if (PyErr_Occurred()) SWIG_fail;
47013 }
47014 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47015 return resultobj;
47016 fail:
47017 return NULL;
47018 }
47019
47020
47021 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47022 PyObject *resultobj = 0;
47023 wxSizer *arg1 = (wxSizer *) 0 ;
47024 wxPoint result;
47025 void *argp1 = 0 ;
47026 int res1 = 0 ;
47027 PyObject *swig_obj[1] ;
47028
47029 if (!args) SWIG_fail;
47030 swig_obj[0] = args;
47031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47032 if (!SWIG_IsOK(res1)) {
47033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47034 }
47035 arg1 = reinterpret_cast< wxSizer * >(argp1);
47036 {
47037 PyThreadState* __tstate = wxPyBeginAllowThreads();
47038 result = (arg1)->GetPosition();
47039 wxPyEndAllowThreads(__tstate);
47040 if (PyErr_Occurred()) SWIG_fail;
47041 }
47042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47043 return resultobj;
47044 fail:
47045 return NULL;
47046 }
47047
47048
47049 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47050 PyObject *resultobj = 0;
47051 wxSizer *arg1 = (wxSizer *) 0 ;
47052 wxSize result;
47053 void *argp1 = 0 ;
47054 int res1 = 0 ;
47055 PyObject *swig_obj[1] ;
47056
47057 if (!args) SWIG_fail;
47058 swig_obj[0] = args;
47059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47060 if (!SWIG_IsOK(res1)) {
47061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47062 }
47063 arg1 = reinterpret_cast< wxSizer * >(argp1);
47064 {
47065 PyThreadState* __tstate = wxPyBeginAllowThreads();
47066 result = (arg1)->GetMinSize();
47067 wxPyEndAllowThreads(__tstate);
47068 if (PyErr_Occurred()) SWIG_fail;
47069 }
47070 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47071 return resultobj;
47072 fail:
47073 return NULL;
47074 }
47075
47076
47077 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47078 PyObject *resultobj = 0;
47079 wxSizer *arg1 = (wxSizer *) 0 ;
47080 void *argp1 = 0 ;
47081 int res1 = 0 ;
47082 PyObject *swig_obj[1] ;
47083
47084 if (!args) SWIG_fail;
47085 swig_obj[0] = args;
47086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47087 if (!SWIG_IsOK(res1)) {
47088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47089 }
47090 arg1 = reinterpret_cast< wxSizer * >(argp1);
47091 {
47092 PyThreadState* __tstate = wxPyBeginAllowThreads();
47093 (arg1)->RecalcSizes();
47094 wxPyEndAllowThreads(__tstate);
47095 if (PyErr_Occurred()) SWIG_fail;
47096 }
47097 resultobj = SWIG_Py_Void();
47098 return resultobj;
47099 fail:
47100 return NULL;
47101 }
47102
47103
47104 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47105 PyObject *resultobj = 0;
47106 wxSizer *arg1 = (wxSizer *) 0 ;
47107 wxSize result;
47108 void *argp1 = 0 ;
47109 int res1 = 0 ;
47110 PyObject *swig_obj[1] ;
47111
47112 if (!args) SWIG_fail;
47113 swig_obj[0] = args;
47114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47115 if (!SWIG_IsOK(res1)) {
47116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47117 }
47118 arg1 = reinterpret_cast< wxSizer * >(argp1);
47119 {
47120 PyThreadState* __tstate = wxPyBeginAllowThreads();
47121 result = (arg1)->CalcMin();
47122 wxPyEndAllowThreads(__tstate);
47123 if (PyErr_Occurred()) SWIG_fail;
47124 }
47125 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47126 return resultobj;
47127 fail:
47128 return NULL;
47129 }
47130
47131
47132 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47133 PyObject *resultobj = 0;
47134 wxSizer *arg1 = (wxSizer *) 0 ;
47135 void *argp1 = 0 ;
47136 int res1 = 0 ;
47137 PyObject *swig_obj[1] ;
47138
47139 if (!args) SWIG_fail;
47140 swig_obj[0] = args;
47141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47142 if (!SWIG_IsOK(res1)) {
47143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47144 }
47145 arg1 = reinterpret_cast< wxSizer * >(argp1);
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 (arg1)->Layout();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_Py_Void();
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47160 PyObject *resultobj = 0;
47161 wxSizer *arg1 = (wxSizer *) 0 ;
47162 wxWindow *arg2 = (wxWindow *) 0 ;
47163 wxSize result;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 void *argp2 = 0 ;
47167 int res2 = 0 ;
47168 PyObject * obj0 = 0 ;
47169 PyObject * obj1 = 0 ;
47170 char * kwnames[] = {
47171 (char *) "self",(char *) "window", NULL
47172 };
47173
47174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47176 if (!SWIG_IsOK(res1)) {
47177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47178 }
47179 arg1 = reinterpret_cast< wxSizer * >(argp1);
47180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47181 if (!SWIG_IsOK(res2)) {
47182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47183 }
47184 arg2 = reinterpret_cast< wxWindow * >(argp2);
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 result = (arg1)->Fit(arg2);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47199 PyObject *resultobj = 0;
47200 wxSizer *arg1 = (wxSizer *) 0 ;
47201 wxWindow *arg2 = (wxWindow *) 0 ;
47202 void *argp1 = 0 ;
47203 int res1 = 0 ;
47204 void *argp2 = 0 ;
47205 int res2 = 0 ;
47206 PyObject * obj0 = 0 ;
47207 PyObject * obj1 = 0 ;
47208 char * kwnames[] = {
47209 (char *) "self",(char *) "window", NULL
47210 };
47211
47212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47214 if (!SWIG_IsOK(res1)) {
47215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47216 }
47217 arg1 = reinterpret_cast< wxSizer * >(argp1);
47218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47219 if (!SWIG_IsOK(res2)) {
47220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47221 }
47222 arg2 = reinterpret_cast< wxWindow * >(argp2);
47223 {
47224 PyThreadState* __tstate = wxPyBeginAllowThreads();
47225 (arg1)->FitInside(arg2);
47226 wxPyEndAllowThreads(__tstate);
47227 if (PyErr_Occurred()) SWIG_fail;
47228 }
47229 resultobj = SWIG_Py_Void();
47230 return resultobj;
47231 fail:
47232 return NULL;
47233 }
47234
47235
47236 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47237 PyObject *resultobj = 0;
47238 wxSizer *arg1 = (wxSizer *) 0 ;
47239 wxWindow *arg2 = (wxWindow *) 0 ;
47240 void *argp1 = 0 ;
47241 int res1 = 0 ;
47242 void *argp2 = 0 ;
47243 int res2 = 0 ;
47244 PyObject * obj0 = 0 ;
47245 PyObject * obj1 = 0 ;
47246 char * kwnames[] = {
47247 (char *) "self",(char *) "window", NULL
47248 };
47249
47250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47252 if (!SWIG_IsOK(res1)) {
47253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47254 }
47255 arg1 = reinterpret_cast< wxSizer * >(argp1);
47256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47257 if (!SWIG_IsOK(res2)) {
47258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47259 }
47260 arg2 = reinterpret_cast< wxWindow * >(argp2);
47261 {
47262 PyThreadState* __tstate = wxPyBeginAllowThreads();
47263 (arg1)->SetSizeHints(arg2);
47264 wxPyEndAllowThreads(__tstate);
47265 if (PyErr_Occurred()) SWIG_fail;
47266 }
47267 resultobj = SWIG_Py_Void();
47268 return resultobj;
47269 fail:
47270 return NULL;
47271 }
47272
47273
47274 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47275 PyObject *resultobj = 0;
47276 wxSizer *arg1 = (wxSizer *) 0 ;
47277 wxWindow *arg2 = (wxWindow *) 0 ;
47278 void *argp1 = 0 ;
47279 int res1 = 0 ;
47280 void *argp2 = 0 ;
47281 int res2 = 0 ;
47282 PyObject * obj0 = 0 ;
47283 PyObject * obj1 = 0 ;
47284 char * kwnames[] = {
47285 (char *) "self",(char *) "window", NULL
47286 };
47287
47288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47290 if (!SWIG_IsOK(res1)) {
47291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47292 }
47293 arg1 = reinterpret_cast< wxSizer * >(argp1);
47294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47295 if (!SWIG_IsOK(res2)) {
47296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47297 }
47298 arg2 = reinterpret_cast< wxWindow * >(argp2);
47299 {
47300 PyThreadState* __tstate = wxPyBeginAllowThreads();
47301 (arg1)->SetVirtualSizeHints(arg2);
47302 wxPyEndAllowThreads(__tstate);
47303 if (PyErr_Occurred()) SWIG_fail;
47304 }
47305 resultobj = SWIG_Py_Void();
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47313 PyObject *resultobj = 0;
47314 wxSizer *arg1 = (wxSizer *) 0 ;
47315 bool arg2 = (bool) false ;
47316 void *argp1 = 0 ;
47317 int res1 = 0 ;
47318 bool val2 ;
47319 int ecode2 = 0 ;
47320 PyObject * obj0 = 0 ;
47321 PyObject * obj1 = 0 ;
47322 char * kwnames[] = {
47323 (char *) "self",(char *) "deleteWindows", NULL
47324 };
47325
47326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47328 if (!SWIG_IsOK(res1)) {
47329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47330 }
47331 arg1 = reinterpret_cast< wxSizer * >(argp1);
47332 if (obj1) {
47333 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47334 if (!SWIG_IsOK(ecode2)) {
47335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47336 }
47337 arg2 = static_cast< bool >(val2);
47338 }
47339 {
47340 PyThreadState* __tstate = wxPyBeginAllowThreads();
47341 (arg1)->Clear(arg2);
47342 wxPyEndAllowThreads(__tstate);
47343 if (PyErr_Occurred()) SWIG_fail;
47344 }
47345 resultobj = SWIG_Py_Void();
47346 return resultobj;
47347 fail:
47348 return NULL;
47349 }
47350
47351
47352 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47353 PyObject *resultobj = 0;
47354 wxSizer *arg1 = (wxSizer *) 0 ;
47355 void *argp1 = 0 ;
47356 int res1 = 0 ;
47357 PyObject *swig_obj[1] ;
47358
47359 if (!args) SWIG_fail;
47360 swig_obj[0] = args;
47361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47362 if (!SWIG_IsOK(res1)) {
47363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47364 }
47365 arg1 = reinterpret_cast< wxSizer * >(argp1);
47366 {
47367 PyThreadState* __tstate = wxPyBeginAllowThreads();
47368 (arg1)->DeleteWindows();
47369 wxPyEndAllowThreads(__tstate);
47370 if (PyErr_Occurred()) SWIG_fail;
47371 }
47372 resultobj = SWIG_Py_Void();
47373 return resultobj;
47374 fail:
47375 return NULL;
47376 }
47377
47378
47379 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47380 PyObject *resultobj = 0;
47381 wxSizer *arg1 = (wxSizer *) 0 ;
47382 PyObject *result = 0 ;
47383 void *argp1 = 0 ;
47384 int res1 = 0 ;
47385 PyObject *swig_obj[1] ;
47386
47387 if (!args) SWIG_fail;
47388 swig_obj[0] = args;
47389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47390 if (!SWIG_IsOK(res1)) {
47391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47392 }
47393 arg1 = reinterpret_cast< wxSizer * >(argp1);
47394 {
47395 PyThreadState* __tstate = wxPyBeginAllowThreads();
47396 result = (PyObject *)wxSizer_GetChildren(arg1);
47397 wxPyEndAllowThreads(__tstate);
47398 if (PyErr_Occurred()) SWIG_fail;
47399 }
47400 resultobj = result;
47401 return resultobj;
47402 fail:
47403 return NULL;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47408 PyObject *resultobj = 0;
47409 wxSizer *arg1 = (wxSizer *) 0 ;
47410 PyObject *arg2 = (PyObject *) 0 ;
47411 bool arg3 = (bool) true ;
47412 bool arg4 = (bool) false ;
47413 bool result;
47414 void *argp1 = 0 ;
47415 int res1 = 0 ;
47416 bool val3 ;
47417 int ecode3 = 0 ;
47418 bool val4 ;
47419 int ecode4 = 0 ;
47420 PyObject * obj0 = 0 ;
47421 PyObject * obj1 = 0 ;
47422 PyObject * obj2 = 0 ;
47423 PyObject * obj3 = 0 ;
47424 char * kwnames[] = {
47425 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47426 };
47427
47428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47430 if (!SWIG_IsOK(res1)) {
47431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47432 }
47433 arg1 = reinterpret_cast< wxSizer * >(argp1);
47434 arg2 = obj1;
47435 if (obj2) {
47436 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47437 if (!SWIG_IsOK(ecode3)) {
47438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47439 }
47440 arg3 = static_cast< bool >(val3);
47441 }
47442 if (obj3) {
47443 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47444 if (!SWIG_IsOK(ecode4)) {
47445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47446 }
47447 arg4 = static_cast< bool >(val4);
47448 }
47449 {
47450 PyThreadState* __tstate = wxPyBeginAllowThreads();
47451 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47452 wxPyEndAllowThreads(__tstate);
47453 if (PyErr_Occurred()) SWIG_fail;
47454 }
47455 {
47456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47457 }
47458 return resultobj;
47459 fail:
47460 return NULL;
47461 }
47462
47463
47464 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47465 PyObject *resultobj = 0;
47466 wxSizer *arg1 = (wxSizer *) 0 ;
47467 PyObject *arg2 = (PyObject *) 0 ;
47468 bool result;
47469 void *argp1 = 0 ;
47470 int res1 = 0 ;
47471 PyObject * obj0 = 0 ;
47472 PyObject * obj1 = 0 ;
47473 char * kwnames[] = {
47474 (char *) "self",(char *) "item", NULL
47475 };
47476
47477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47479 if (!SWIG_IsOK(res1)) {
47480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47481 }
47482 arg1 = reinterpret_cast< wxSizer * >(argp1);
47483 arg2 = obj1;
47484 {
47485 PyThreadState* __tstate = wxPyBeginAllowThreads();
47486 result = (bool)wxSizer_IsShown(arg1,arg2);
47487 wxPyEndAllowThreads(__tstate);
47488 if (PyErr_Occurred()) SWIG_fail;
47489 }
47490 {
47491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47492 }
47493 return resultobj;
47494 fail:
47495 return NULL;
47496 }
47497
47498
47499 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47500 PyObject *resultobj = 0;
47501 wxSizer *arg1 = (wxSizer *) 0 ;
47502 bool arg2 ;
47503 void *argp1 = 0 ;
47504 int res1 = 0 ;
47505 bool val2 ;
47506 int ecode2 = 0 ;
47507 PyObject * obj0 = 0 ;
47508 PyObject * obj1 = 0 ;
47509 char * kwnames[] = {
47510 (char *) "self",(char *) "show", NULL
47511 };
47512
47513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47515 if (!SWIG_IsOK(res1)) {
47516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47517 }
47518 arg1 = reinterpret_cast< wxSizer * >(argp1);
47519 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47520 if (!SWIG_IsOK(ecode2)) {
47521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47522 }
47523 arg2 = static_cast< bool >(val2);
47524 {
47525 PyThreadState* __tstate = wxPyBeginAllowThreads();
47526 (arg1)->ShowItems(arg2);
47527 wxPyEndAllowThreads(__tstate);
47528 if (PyErr_Occurred()) SWIG_fail;
47529 }
47530 resultobj = SWIG_Py_Void();
47531 return resultobj;
47532 fail:
47533 return NULL;
47534 }
47535
47536
47537 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47538 PyObject *obj;
47539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47540 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47541 return SWIG_Py_Void();
47542 }
47543
47544 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47545 PyObject *resultobj = 0;
47546 wxPySizer *result = 0 ;
47547
47548 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47549 {
47550 PyThreadState* __tstate = wxPyBeginAllowThreads();
47551 result = (wxPySizer *)new wxPySizer();
47552 wxPyEndAllowThreads(__tstate);
47553 if (PyErr_Occurred()) SWIG_fail;
47554 }
47555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47556 return resultobj;
47557 fail:
47558 return NULL;
47559 }
47560
47561
47562 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47563 PyObject *resultobj = 0;
47564 wxPySizer *arg1 = (wxPySizer *) 0 ;
47565 PyObject *arg2 = (PyObject *) 0 ;
47566 PyObject *arg3 = (PyObject *) 0 ;
47567 void *argp1 = 0 ;
47568 int res1 = 0 ;
47569 PyObject * obj0 = 0 ;
47570 PyObject * obj1 = 0 ;
47571 PyObject * obj2 = 0 ;
47572 char * kwnames[] = {
47573 (char *) "self",(char *) "self",(char *) "_class", NULL
47574 };
47575
47576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47578 if (!SWIG_IsOK(res1)) {
47579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47580 }
47581 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47582 arg2 = obj1;
47583 arg3 = obj2;
47584 {
47585 PyThreadState* __tstate = wxPyBeginAllowThreads();
47586 (arg1)->_setCallbackInfo(arg2,arg3);
47587 wxPyEndAllowThreads(__tstate);
47588 if (PyErr_Occurred()) SWIG_fail;
47589 }
47590 resultobj = SWIG_Py_Void();
47591 return resultobj;
47592 fail:
47593 return NULL;
47594 }
47595
47596
47597 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47598 PyObject *obj;
47599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47600 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47601 return SWIG_Py_Void();
47602 }
47603
47604 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47605 return SWIG_Python_InitShadowInstance(args);
47606 }
47607
47608 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47609 PyObject *resultobj = 0;
47610 int arg1 = (int) wxHORIZONTAL ;
47611 wxBoxSizer *result = 0 ;
47612 int val1 ;
47613 int ecode1 = 0 ;
47614 PyObject * obj0 = 0 ;
47615 char * kwnames[] = {
47616 (char *) "orient", NULL
47617 };
47618
47619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47620 if (obj0) {
47621 ecode1 = SWIG_AsVal_int(obj0, &val1);
47622 if (!SWIG_IsOK(ecode1)) {
47623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47624 }
47625 arg1 = static_cast< int >(val1);
47626 }
47627 {
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47634 return resultobj;
47635 fail:
47636 return NULL;
47637 }
47638
47639
47640 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 PyObject *resultobj = 0;
47642 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47643 int result;
47644 void *argp1 = 0 ;
47645 int res1 = 0 ;
47646 PyObject *swig_obj[1] ;
47647
47648 if (!args) SWIG_fail;
47649 swig_obj[0] = args;
47650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47651 if (!SWIG_IsOK(res1)) {
47652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47653 }
47654 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47655 {
47656 PyThreadState* __tstate = wxPyBeginAllowThreads();
47657 result = (int)(arg1)->GetOrientation();
47658 wxPyEndAllowThreads(__tstate);
47659 if (PyErr_Occurred()) SWIG_fail;
47660 }
47661 resultobj = SWIG_From_int(static_cast< int >(result));
47662 return resultobj;
47663 fail:
47664 return NULL;
47665 }
47666
47667
47668 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47669 PyObject *resultobj = 0;
47670 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47671 int arg2 ;
47672 void *argp1 = 0 ;
47673 int res1 = 0 ;
47674 int val2 ;
47675 int ecode2 = 0 ;
47676 PyObject * obj0 = 0 ;
47677 PyObject * obj1 = 0 ;
47678 char * kwnames[] = {
47679 (char *) "self",(char *) "orient", NULL
47680 };
47681
47682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47684 if (!SWIG_IsOK(res1)) {
47685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47686 }
47687 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47688 ecode2 = SWIG_AsVal_int(obj1, &val2);
47689 if (!SWIG_IsOK(ecode2)) {
47690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47691 }
47692 arg2 = static_cast< int >(val2);
47693 {
47694 PyThreadState* __tstate = wxPyBeginAllowThreads();
47695 (arg1)->SetOrientation(arg2);
47696 wxPyEndAllowThreads(__tstate);
47697 if (PyErr_Occurred()) SWIG_fail;
47698 }
47699 resultobj = SWIG_Py_Void();
47700 return resultobj;
47701 fail:
47702 return NULL;
47703 }
47704
47705
47706 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47707 PyObject *obj;
47708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47709 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47710 return SWIG_Py_Void();
47711 }
47712
47713 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47714 return SWIG_Python_InitShadowInstance(args);
47715 }
47716
47717 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47718 PyObject *resultobj = 0;
47719 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47720 int arg2 = (int) wxHORIZONTAL ;
47721 wxStaticBoxSizer *result = 0 ;
47722 void *argp1 = 0 ;
47723 int res1 = 0 ;
47724 int val2 ;
47725 int ecode2 = 0 ;
47726 PyObject * obj0 = 0 ;
47727 PyObject * obj1 = 0 ;
47728 char * kwnames[] = {
47729 (char *) "box",(char *) "orient", NULL
47730 };
47731
47732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47734 if (!SWIG_IsOK(res1)) {
47735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47736 }
47737 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47738 if (obj1) {
47739 ecode2 = SWIG_AsVal_int(obj1, &val2);
47740 if (!SWIG_IsOK(ecode2)) {
47741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47742 }
47743 arg2 = static_cast< int >(val2);
47744 }
47745 {
47746 PyThreadState* __tstate = wxPyBeginAllowThreads();
47747 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47748 wxPyEndAllowThreads(__tstate);
47749 if (PyErr_Occurred()) SWIG_fail;
47750 }
47751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47752 return resultobj;
47753 fail:
47754 return NULL;
47755 }
47756
47757
47758 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47759 PyObject *resultobj = 0;
47760 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47761 wxStaticBox *result = 0 ;
47762 void *argp1 = 0 ;
47763 int res1 = 0 ;
47764 PyObject *swig_obj[1] ;
47765
47766 if (!args) SWIG_fail;
47767 swig_obj[0] = args;
47768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47769 if (!SWIG_IsOK(res1)) {
47770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47771 }
47772 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47773 {
47774 PyThreadState* __tstate = wxPyBeginAllowThreads();
47775 result = (wxStaticBox *)(arg1)->GetStaticBox();
47776 wxPyEndAllowThreads(__tstate);
47777 if (PyErr_Occurred()) SWIG_fail;
47778 }
47779 {
47780 resultobj = wxPyMake_wxObject(result, (bool)0);
47781 }
47782 return resultobj;
47783 fail:
47784 return NULL;
47785 }
47786
47787
47788 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47789 PyObject *obj;
47790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47791 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47792 return SWIG_Py_Void();
47793 }
47794
47795 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47796 return SWIG_Python_InitShadowInstance(args);
47797 }
47798
47799 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47800 PyObject *resultobj = 0;
47801 int arg1 = (int) 1 ;
47802 int arg2 = (int) 0 ;
47803 int arg3 = (int) 0 ;
47804 int arg4 = (int) 0 ;
47805 wxGridSizer *result = 0 ;
47806 int val1 ;
47807 int ecode1 = 0 ;
47808 int val2 ;
47809 int ecode2 = 0 ;
47810 int val3 ;
47811 int ecode3 = 0 ;
47812 int val4 ;
47813 int ecode4 = 0 ;
47814 PyObject * obj0 = 0 ;
47815 PyObject * obj1 = 0 ;
47816 PyObject * obj2 = 0 ;
47817 PyObject * obj3 = 0 ;
47818 char * kwnames[] = {
47819 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47820 };
47821
47822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47823 if (obj0) {
47824 ecode1 = SWIG_AsVal_int(obj0, &val1);
47825 if (!SWIG_IsOK(ecode1)) {
47826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47827 }
47828 arg1 = static_cast< int >(val1);
47829 }
47830 if (obj1) {
47831 ecode2 = SWIG_AsVal_int(obj1, &val2);
47832 if (!SWIG_IsOK(ecode2)) {
47833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47834 }
47835 arg2 = static_cast< int >(val2);
47836 }
47837 if (obj2) {
47838 ecode3 = SWIG_AsVal_int(obj2, &val3);
47839 if (!SWIG_IsOK(ecode3)) {
47840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47841 }
47842 arg3 = static_cast< int >(val3);
47843 }
47844 if (obj3) {
47845 ecode4 = SWIG_AsVal_int(obj3, &val4);
47846 if (!SWIG_IsOK(ecode4)) {
47847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47848 }
47849 arg4 = static_cast< int >(val4);
47850 }
47851 {
47852 PyThreadState* __tstate = wxPyBeginAllowThreads();
47853 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47854 wxPyEndAllowThreads(__tstate);
47855 if (PyErr_Occurred()) SWIG_fail;
47856 }
47857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47858 return resultobj;
47859 fail:
47860 return NULL;
47861 }
47862
47863
47864 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47865 PyObject *resultobj = 0;
47866 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47867 int arg2 ;
47868 void *argp1 = 0 ;
47869 int res1 = 0 ;
47870 int val2 ;
47871 int ecode2 = 0 ;
47872 PyObject * obj0 = 0 ;
47873 PyObject * obj1 = 0 ;
47874 char * kwnames[] = {
47875 (char *) "self",(char *) "cols", NULL
47876 };
47877
47878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47880 if (!SWIG_IsOK(res1)) {
47881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47882 }
47883 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47884 ecode2 = SWIG_AsVal_int(obj1, &val2);
47885 if (!SWIG_IsOK(ecode2)) {
47886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47887 }
47888 arg2 = static_cast< int >(val2);
47889 {
47890 PyThreadState* __tstate = wxPyBeginAllowThreads();
47891 (arg1)->SetCols(arg2);
47892 wxPyEndAllowThreads(__tstate);
47893 if (PyErr_Occurred()) SWIG_fail;
47894 }
47895 resultobj = SWIG_Py_Void();
47896 return resultobj;
47897 fail:
47898 return NULL;
47899 }
47900
47901
47902 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47903 PyObject *resultobj = 0;
47904 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47905 int arg2 ;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 int val2 ;
47909 int ecode2 = 0 ;
47910 PyObject * obj0 = 0 ;
47911 PyObject * obj1 = 0 ;
47912 char * kwnames[] = {
47913 (char *) "self",(char *) "rows", NULL
47914 };
47915
47916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47918 if (!SWIG_IsOK(res1)) {
47919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47920 }
47921 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47922 ecode2 = SWIG_AsVal_int(obj1, &val2);
47923 if (!SWIG_IsOK(ecode2)) {
47924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47925 }
47926 arg2 = static_cast< int >(val2);
47927 {
47928 PyThreadState* __tstate = wxPyBeginAllowThreads();
47929 (arg1)->SetRows(arg2);
47930 wxPyEndAllowThreads(__tstate);
47931 if (PyErr_Occurred()) SWIG_fail;
47932 }
47933 resultobj = SWIG_Py_Void();
47934 return resultobj;
47935 fail:
47936 return NULL;
47937 }
47938
47939
47940 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47941 PyObject *resultobj = 0;
47942 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47943 int arg2 ;
47944 void *argp1 = 0 ;
47945 int res1 = 0 ;
47946 int val2 ;
47947 int ecode2 = 0 ;
47948 PyObject * obj0 = 0 ;
47949 PyObject * obj1 = 0 ;
47950 char * kwnames[] = {
47951 (char *) "self",(char *) "gap", NULL
47952 };
47953
47954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47956 if (!SWIG_IsOK(res1)) {
47957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47958 }
47959 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47960 ecode2 = SWIG_AsVal_int(obj1, &val2);
47961 if (!SWIG_IsOK(ecode2)) {
47962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47963 }
47964 arg2 = static_cast< int >(val2);
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 (arg1)->SetVGap(arg2);
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 resultobj = SWIG_Py_Void();
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47979 PyObject *resultobj = 0;
47980 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47981 int arg2 ;
47982 void *argp1 = 0 ;
47983 int res1 = 0 ;
47984 int val2 ;
47985 int ecode2 = 0 ;
47986 PyObject * obj0 = 0 ;
47987 PyObject * obj1 = 0 ;
47988 char * kwnames[] = {
47989 (char *) "self",(char *) "gap", NULL
47990 };
47991
47992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47994 if (!SWIG_IsOK(res1)) {
47995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47996 }
47997 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47998 ecode2 = SWIG_AsVal_int(obj1, &val2);
47999 if (!SWIG_IsOK(ecode2)) {
48000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48001 }
48002 arg2 = static_cast< int >(val2);
48003 {
48004 PyThreadState* __tstate = wxPyBeginAllowThreads();
48005 (arg1)->SetHGap(arg2);
48006 wxPyEndAllowThreads(__tstate);
48007 if (PyErr_Occurred()) SWIG_fail;
48008 }
48009 resultobj = SWIG_Py_Void();
48010 return resultobj;
48011 fail:
48012 return NULL;
48013 }
48014
48015
48016 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48017 PyObject *resultobj = 0;
48018 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48019 int result;
48020 void *argp1 = 0 ;
48021 int res1 = 0 ;
48022 PyObject *swig_obj[1] ;
48023
48024 if (!args) SWIG_fail;
48025 swig_obj[0] = args;
48026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48027 if (!SWIG_IsOK(res1)) {
48028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48029 }
48030 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48031 {
48032 PyThreadState* __tstate = wxPyBeginAllowThreads();
48033 result = (int)(arg1)->GetCols();
48034 wxPyEndAllowThreads(__tstate);
48035 if (PyErr_Occurred()) SWIG_fail;
48036 }
48037 resultobj = SWIG_From_int(static_cast< int >(result));
48038 return resultobj;
48039 fail:
48040 return NULL;
48041 }
48042
48043
48044 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48045 PyObject *resultobj = 0;
48046 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48047 int result;
48048 void *argp1 = 0 ;
48049 int res1 = 0 ;
48050 PyObject *swig_obj[1] ;
48051
48052 if (!args) SWIG_fail;
48053 swig_obj[0] = args;
48054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48055 if (!SWIG_IsOK(res1)) {
48056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48057 }
48058 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48059 {
48060 PyThreadState* __tstate = wxPyBeginAllowThreads();
48061 result = (int)(arg1)->GetRows();
48062 wxPyEndAllowThreads(__tstate);
48063 if (PyErr_Occurred()) SWIG_fail;
48064 }
48065 resultobj = SWIG_From_int(static_cast< int >(result));
48066 return resultobj;
48067 fail:
48068 return NULL;
48069 }
48070
48071
48072 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48073 PyObject *resultobj = 0;
48074 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48075 int result;
48076 void *argp1 = 0 ;
48077 int res1 = 0 ;
48078 PyObject *swig_obj[1] ;
48079
48080 if (!args) SWIG_fail;
48081 swig_obj[0] = args;
48082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48083 if (!SWIG_IsOK(res1)) {
48084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48085 }
48086 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48087 {
48088 PyThreadState* __tstate = wxPyBeginAllowThreads();
48089 result = (int)(arg1)->GetVGap();
48090 wxPyEndAllowThreads(__tstate);
48091 if (PyErr_Occurred()) SWIG_fail;
48092 }
48093 resultobj = SWIG_From_int(static_cast< int >(result));
48094 return resultobj;
48095 fail:
48096 return NULL;
48097 }
48098
48099
48100 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48101 PyObject *resultobj = 0;
48102 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48103 int result;
48104 void *argp1 = 0 ;
48105 int res1 = 0 ;
48106 PyObject *swig_obj[1] ;
48107
48108 if (!args) SWIG_fail;
48109 swig_obj[0] = args;
48110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48111 if (!SWIG_IsOK(res1)) {
48112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48113 }
48114 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48115 {
48116 PyThreadState* __tstate = wxPyBeginAllowThreads();
48117 result = (int)(arg1)->GetHGap();
48118 wxPyEndAllowThreads(__tstate);
48119 if (PyErr_Occurred()) SWIG_fail;
48120 }
48121 resultobj = SWIG_From_int(static_cast< int >(result));
48122 return resultobj;
48123 fail:
48124 return NULL;
48125 }
48126
48127
48128 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48129 PyObject *obj;
48130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48131 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48132 return SWIG_Py_Void();
48133 }
48134
48135 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48136 return SWIG_Python_InitShadowInstance(args);
48137 }
48138
48139 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48140 PyObject *resultobj = 0;
48141 int arg1 = (int) 1 ;
48142 int arg2 = (int) 0 ;
48143 int arg3 = (int) 0 ;
48144 int arg4 = (int) 0 ;
48145 wxFlexGridSizer *result = 0 ;
48146 int val1 ;
48147 int ecode1 = 0 ;
48148 int val2 ;
48149 int ecode2 = 0 ;
48150 int val3 ;
48151 int ecode3 = 0 ;
48152 int val4 ;
48153 int ecode4 = 0 ;
48154 PyObject * obj0 = 0 ;
48155 PyObject * obj1 = 0 ;
48156 PyObject * obj2 = 0 ;
48157 PyObject * obj3 = 0 ;
48158 char * kwnames[] = {
48159 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48160 };
48161
48162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48163 if (obj0) {
48164 ecode1 = SWIG_AsVal_int(obj0, &val1);
48165 if (!SWIG_IsOK(ecode1)) {
48166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48167 }
48168 arg1 = static_cast< int >(val1);
48169 }
48170 if (obj1) {
48171 ecode2 = SWIG_AsVal_int(obj1, &val2);
48172 if (!SWIG_IsOK(ecode2)) {
48173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48174 }
48175 arg2 = static_cast< int >(val2);
48176 }
48177 if (obj2) {
48178 ecode3 = SWIG_AsVal_int(obj2, &val3);
48179 if (!SWIG_IsOK(ecode3)) {
48180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48181 }
48182 arg3 = static_cast< int >(val3);
48183 }
48184 if (obj3) {
48185 ecode4 = SWIG_AsVal_int(obj3, &val4);
48186 if (!SWIG_IsOK(ecode4)) {
48187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48188 }
48189 arg4 = static_cast< int >(val4);
48190 }
48191 {
48192 PyThreadState* __tstate = wxPyBeginAllowThreads();
48193 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48194 wxPyEndAllowThreads(__tstate);
48195 if (PyErr_Occurred()) SWIG_fail;
48196 }
48197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48198 return resultobj;
48199 fail:
48200 return NULL;
48201 }
48202
48203
48204 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48205 PyObject *resultobj = 0;
48206 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48207 size_t arg2 ;
48208 int arg3 = (int) 0 ;
48209 void *argp1 = 0 ;
48210 int res1 = 0 ;
48211 size_t val2 ;
48212 int ecode2 = 0 ;
48213 int val3 ;
48214 int ecode3 = 0 ;
48215 PyObject * obj0 = 0 ;
48216 PyObject * obj1 = 0 ;
48217 PyObject * obj2 = 0 ;
48218 char * kwnames[] = {
48219 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48220 };
48221
48222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48224 if (!SWIG_IsOK(res1)) {
48225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48226 }
48227 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48228 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48229 if (!SWIG_IsOK(ecode2)) {
48230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48231 }
48232 arg2 = static_cast< size_t >(val2);
48233 if (obj2) {
48234 ecode3 = SWIG_AsVal_int(obj2, &val3);
48235 if (!SWIG_IsOK(ecode3)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48237 }
48238 arg3 = static_cast< int >(val3);
48239 }
48240 {
48241 PyThreadState* __tstate = wxPyBeginAllowThreads();
48242 (arg1)->AddGrowableRow(arg2,arg3);
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 resultobj = SWIG_Py_Void();
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48254 PyObject *resultobj = 0;
48255 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48256 size_t arg2 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 size_t val2 ;
48260 int ecode2 = 0 ;
48261 PyObject * obj0 = 0 ;
48262 PyObject * obj1 = 0 ;
48263 char * kwnames[] = {
48264 (char *) "self",(char *) "idx", NULL
48265 };
48266
48267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48271 }
48272 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48273 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48274 if (!SWIG_IsOK(ecode2)) {
48275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48276 }
48277 arg2 = static_cast< size_t >(val2);
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 (arg1)->RemoveGrowableRow(arg2);
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = SWIG_Py_Void();
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48294 size_t arg2 ;
48295 int arg3 = (int) 0 ;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 size_t val2 ;
48299 int ecode2 = 0 ;
48300 int val3 ;
48301 int ecode3 = 0 ;
48302 PyObject * obj0 = 0 ;
48303 PyObject * obj1 = 0 ;
48304 PyObject * obj2 = 0 ;
48305 char * kwnames[] = {
48306 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48307 };
48308
48309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48311 if (!SWIG_IsOK(res1)) {
48312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48313 }
48314 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48315 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48316 if (!SWIG_IsOK(ecode2)) {
48317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48318 }
48319 arg2 = static_cast< size_t >(val2);
48320 if (obj2) {
48321 ecode3 = SWIG_AsVal_int(obj2, &val3);
48322 if (!SWIG_IsOK(ecode3)) {
48323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48324 }
48325 arg3 = static_cast< int >(val3);
48326 }
48327 {
48328 PyThreadState* __tstate = wxPyBeginAllowThreads();
48329 (arg1)->AddGrowableCol(arg2,arg3);
48330 wxPyEndAllowThreads(__tstate);
48331 if (PyErr_Occurred()) SWIG_fail;
48332 }
48333 resultobj = SWIG_Py_Void();
48334 return resultobj;
48335 fail:
48336 return NULL;
48337 }
48338
48339
48340 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48341 PyObject *resultobj = 0;
48342 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48343 size_t arg2 ;
48344 void *argp1 = 0 ;
48345 int res1 = 0 ;
48346 size_t val2 ;
48347 int ecode2 = 0 ;
48348 PyObject * obj0 = 0 ;
48349 PyObject * obj1 = 0 ;
48350 char * kwnames[] = {
48351 (char *) "self",(char *) "idx", NULL
48352 };
48353
48354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48356 if (!SWIG_IsOK(res1)) {
48357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48358 }
48359 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48360 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48361 if (!SWIG_IsOK(ecode2)) {
48362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48363 }
48364 arg2 = static_cast< size_t >(val2);
48365 {
48366 PyThreadState* __tstate = wxPyBeginAllowThreads();
48367 (arg1)->RemoveGrowableCol(arg2);
48368 wxPyEndAllowThreads(__tstate);
48369 if (PyErr_Occurred()) SWIG_fail;
48370 }
48371 resultobj = SWIG_Py_Void();
48372 return resultobj;
48373 fail:
48374 return NULL;
48375 }
48376
48377
48378 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48379 PyObject *resultobj = 0;
48380 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48381 int arg2 ;
48382 void *argp1 = 0 ;
48383 int res1 = 0 ;
48384 int val2 ;
48385 int ecode2 = 0 ;
48386 PyObject * obj0 = 0 ;
48387 PyObject * obj1 = 0 ;
48388 char * kwnames[] = {
48389 (char *) "self",(char *) "direction", NULL
48390 };
48391
48392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48394 if (!SWIG_IsOK(res1)) {
48395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48396 }
48397 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48398 ecode2 = SWIG_AsVal_int(obj1, &val2);
48399 if (!SWIG_IsOK(ecode2)) {
48400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48401 }
48402 arg2 = static_cast< int >(val2);
48403 {
48404 PyThreadState* __tstate = wxPyBeginAllowThreads();
48405 (arg1)->SetFlexibleDirection(arg2);
48406 wxPyEndAllowThreads(__tstate);
48407 if (PyErr_Occurred()) SWIG_fail;
48408 }
48409 resultobj = SWIG_Py_Void();
48410 return resultobj;
48411 fail:
48412 return NULL;
48413 }
48414
48415
48416 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48417 PyObject *resultobj = 0;
48418 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48419 int result;
48420 void *argp1 = 0 ;
48421 int res1 = 0 ;
48422 PyObject *swig_obj[1] ;
48423
48424 if (!args) SWIG_fail;
48425 swig_obj[0] = args;
48426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48427 if (!SWIG_IsOK(res1)) {
48428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48429 }
48430 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48431 {
48432 PyThreadState* __tstate = wxPyBeginAllowThreads();
48433 result = (int)(arg1)->GetFlexibleDirection();
48434 wxPyEndAllowThreads(__tstate);
48435 if (PyErr_Occurred()) SWIG_fail;
48436 }
48437 resultobj = SWIG_From_int(static_cast< int >(result));
48438 return resultobj;
48439 fail:
48440 return NULL;
48441 }
48442
48443
48444 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48445 PyObject *resultobj = 0;
48446 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48447 wxFlexSizerGrowMode arg2 ;
48448 void *argp1 = 0 ;
48449 int res1 = 0 ;
48450 int val2 ;
48451 int ecode2 = 0 ;
48452 PyObject * obj0 = 0 ;
48453 PyObject * obj1 = 0 ;
48454 char * kwnames[] = {
48455 (char *) "self",(char *) "mode", NULL
48456 };
48457
48458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) 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_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48462 }
48463 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48464 ecode2 = SWIG_AsVal_int(obj1, &val2);
48465 if (!SWIG_IsOK(ecode2)) {
48466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48467 }
48468 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48469 {
48470 PyThreadState* __tstate = wxPyBeginAllowThreads();
48471 (arg1)->SetNonFlexibleGrowMode(arg2);
48472 wxPyEndAllowThreads(__tstate);
48473 if (PyErr_Occurred()) SWIG_fail;
48474 }
48475 resultobj = SWIG_Py_Void();
48476 return resultobj;
48477 fail:
48478 return NULL;
48479 }
48480
48481
48482 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48483 PyObject *resultobj = 0;
48484 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48485 wxFlexSizerGrowMode result;
48486 void *argp1 = 0 ;
48487 int res1 = 0 ;
48488 PyObject *swig_obj[1] ;
48489
48490 if (!args) SWIG_fail;
48491 swig_obj[0] = args;
48492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48493 if (!SWIG_IsOK(res1)) {
48494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48495 }
48496 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48497 {
48498 PyThreadState* __tstate = wxPyBeginAllowThreads();
48499 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48500 wxPyEndAllowThreads(__tstate);
48501 if (PyErr_Occurred()) SWIG_fail;
48502 }
48503 resultobj = SWIG_From_int(static_cast< int >(result));
48504 return resultobj;
48505 fail:
48506 return NULL;
48507 }
48508
48509
48510 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48511 PyObject *resultobj = 0;
48512 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48513 wxArrayInt *result = 0 ;
48514 void *argp1 = 0 ;
48515 int res1 = 0 ;
48516 PyObject *swig_obj[1] ;
48517
48518 if (!args) SWIG_fail;
48519 swig_obj[0] = args;
48520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48521 if (!SWIG_IsOK(res1)) {
48522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48523 }
48524 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48525 {
48526 PyThreadState* __tstate = wxPyBeginAllowThreads();
48527 {
48528 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48529 result = (wxArrayInt *) &_result_ref;
48530 }
48531 wxPyEndAllowThreads(__tstate);
48532 if (PyErr_Occurred()) SWIG_fail;
48533 }
48534 {
48535 resultobj = PyList_New(0);
48536 size_t idx;
48537 for (idx = 0; idx < result->GetCount(); idx += 1) {
48538 PyObject* val = PyInt_FromLong( result->Item(idx) );
48539 PyList_Append(resultobj, val);
48540 Py_DECREF(val);
48541 }
48542 }
48543 return resultobj;
48544 fail:
48545 return NULL;
48546 }
48547
48548
48549 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48550 PyObject *resultobj = 0;
48551 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48552 wxArrayInt *result = 0 ;
48553 void *argp1 = 0 ;
48554 int res1 = 0 ;
48555 PyObject *swig_obj[1] ;
48556
48557 if (!args) SWIG_fail;
48558 swig_obj[0] = args;
48559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48560 if (!SWIG_IsOK(res1)) {
48561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48562 }
48563 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48564 {
48565 PyThreadState* __tstate = wxPyBeginAllowThreads();
48566 {
48567 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48568 result = (wxArrayInt *) &_result_ref;
48569 }
48570 wxPyEndAllowThreads(__tstate);
48571 if (PyErr_Occurred()) SWIG_fail;
48572 }
48573 {
48574 resultobj = PyList_New(0);
48575 size_t idx;
48576 for (idx = 0; idx < result->GetCount(); idx += 1) {
48577 PyObject* val = PyInt_FromLong( result->Item(idx) );
48578 PyList_Append(resultobj, val);
48579 Py_DECREF(val);
48580 }
48581 }
48582 return resultobj;
48583 fail:
48584 return NULL;
48585 }
48586
48587
48588 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48589 PyObject *obj;
48590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48591 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48592 return SWIG_Py_Void();
48593 }
48594
48595 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48596 return SWIG_Python_InitShadowInstance(args);
48597 }
48598
48599 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48600 PyObject *resultobj = 0;
48601 wxStdDialogButtonSizer *result = 0 ;
48602
48603 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48611 return resultobj;
48612 fail:
48613 return NULL;
48614 }
48615
48616
48617 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48618 PyObject *resultobj = 0;
48619 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48620 wxButton *arg2 = (wxButton *) 0 ;
48621 void *argp1 = 0 ;
48622 int res1 = 0 ;
48623 void *argp2 = 0 ;
48624 int res2 = 0 ;
48625 PyObject * obj0 = 0 ;
48626 PyObject * obj1 = 0 ;
48627 char * kwnames[] = {
48628 (char *) "self",(char *) "button", NULL
48629 };
48630
48631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48633 if (!SWIG_IsOK(res1)) {
48634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48635 }
48636 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48638 if (!SWIG_IsOK(res2)) {
48639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48640 }
48641 arg2 = reinterpret_cast< wxButton * >(argp2);
48642 {
48643 PyThreadState* __tstate = wxPyBeginAllowThreads();
48644 (arg1)->AddButton(arg2);
48645 wxPyEndAllowThreads(__tstate);
48646 if (PyErr_Occurred()) SWIG_fail;
48647 }
48648 resultobj = SWIG_Py_Void();
48649 return resultobj;
48650 fail:
48651 return NULL;
48652 }
48653
48654
48655 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48656 PyObject *resultobj = 0;
48657 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48658 void *argp1 = 0 ;
48659 int res1 = 0 ;
48660 PyObject *swig_obj[1] ;
48661
48662 if (!args) SWIG_fail;
48663 swig_obj[0] = args;
48664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48665 if (!SWIG_IsOK(res1)) {
48666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48667 }
48668 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48669 {
48670 PyThreadState* __tstate = wxPyBeginAllowThreads();
48671 (arg1)->Realize();
48672 wxPyEndAllowThreads(__tstate);
48673 if (PyErr_Occurred()) SWIG_fail;
48674 }
48675 resultobj = SWIG_Py_Void();
48676 return resultobj;
48677 fail:
48678 return NULL;
48679 }
48680
48681
48682 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48683 PyObject *resultobj = 0;
48684 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48685 wxButton *arg2 = (wxButton *) 0 ;
48686 void *argp1 = 0 ;
48687 int res1 = 0 ;
48688 void *argp2 = 0 ;
48689 int res2 = 0 ;
48690 PyObject * obj0 = 0 ;
48691 PyObject * obj1 = 0 ;
48692 char * kwnames[] = {
48693 (char *) "self",(char *) "button", NULL
48694 };
48695
48696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48698 if (!SWIG_IsOK(res1)) {
48699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48700 }
48701 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48703 if (!SWIG_IsOK(res2)) {
48704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48705 }
48706 arg2 = reinterpret_cast< wxButton * >(argp2);
48707 {
48708 PyThreadState* __tstate = wxPyBeginAllowThreads();
48709 (arg1)->SetAffirmativeButton(arg2);
48710 wxPyEndAllowThreads(__tstate);
48711 if (PyErr_Occurred()) SWIG_fail;
48712 }
48713 resultobj = SWIG_Py_Void();
48714 return resultobj;
48715 fail:
48716 return NULL;
48717 }
48718
48719
48720 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48721 PyObject *resultobj = 0;
48722 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48723 wxButton *arg2 = (wxButton *) 0 ;
48724 void *argp1 = 0 ;
48725 int res1 = 0 ;
48726 void *argp2 = 0 ;
48727 int res2 = 0 ;
48728 PyObject * obj0 = 0 ;
48729 PyObject * obj1 = 0 ;
48730 char * kwnames[] = {
48731 (char *) "self",(char *) "button", NULL
48732 };
48733
48734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48736 if (!SWIG_IsOK(res1)) {
48737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48738 }
48739 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48741 if (!SWIG_IsOK(res2)) {
48742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48743 }
48744 arg2 = reinterpret_cast< wxButton * >(argp2);
48745 {
48746 PyThreadState* __tstate = wxPyBeginAllowThreads();
48747 (arg1)->SetNegativeButton(arg2);
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 resultobj = SWIG_Py_Void();
48752 return resultobj;
48753 fail:
48754 return NULL;
48755 }
48756
48757
48758 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48759 PyObject *resultobj = 0;
48760 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48761 wxButton *arg2 = (wxButton *) 0 ;
48762 void *argp1 = 0 ;
48763 int res1 = 0 ;
48764 void *argp2 = 0 ;
48765 int res2 = 0 ;
48766 PyObject * obj0 = 0 ;
48767 PyObject * obj1 = 0 ;
48768 char * kwnames[] = {
48769 (char *) "self",(char *) "button", NULL
48770 };
48771
48772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48774 if (!SWIG_IsOK(res1)) {
48775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48776 }
48777 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48779 if (!SWIG_IsOK(res2)) {
48780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48781 }
48782 arg2 = reinterpret_cast< wxButton * >(argp2);
48783 {
48784 PyThreadState* __tstate = wxPyBeginAllowThreads();
48785 (arg1)->SetCancelButton(arg2);
48786 wxPyEndAllowThreads(__tstate);
48787 if (PyErr_Occurred()) SWIG_fail;
48788 }
48789 resultobj = SWIG_Py_Void();
48790 return resultobj;
48791 fail:
48792 return NULL;
48793 }
48794
48795
48796 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48797 PyObject *resultobj = 0;
48798 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48799 wxButton *result = 0 ;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 PyObject *swig_obj[1] ;
48803
48804 if (!args) SWIG_fail;
48805 swig_obj[0] = args;
48806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48809 }
48810 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48811 {
48812 PyThreadState* __tstate = wxPyBeginAllowThreads();
48813 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48814 wxPyEndAllowThreads(__tstate);
48815 if (PyErr_Occurred()) SWIG_fail;
48816 }
48817 {
48818 resultobj = wxPyMake_wxObject(result, (bool)0);
48819 }
48820 return resultobj;
48821 fail:
48822 return NULL;
48823 }
48824
48825
48826 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48827 PyObject *resultobj = 0;
48828 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48829 wxButton *result = 0 ;
48830 void *argp1 = 0 ;
48831 int res1 = 0 ;
48832 PyObject *swig_obj[1] ;
48833
48834 if (!args) SWIG_fail;
48835 swig_obj[0] = args;
48836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48837 if (!SWIG_IsOK(res1)) {
48838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48839 }
48840 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48841 {
48842 PyThreadState* __tstate = wxPyBeginAllowThreads();
48843 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48844 wxPyEndAllowThreads(__tstate);
48845 if (PyErr_Occurred()) SWIG_fail;
48846 }
48847 {
48848 resultobj = wxPyMake_wxObject(result, (bool)0);
48849 }
48850 return resultobj;
48851 fail:
48852 return NULL;
48853 }
48854
48855
48856 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48857 PyObject *resultobj = 0;
48858 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48859 wxButton *result = 0 ;
48860 void *argp1 = 0 ;
48861 int res1 = 0 ;
48862 PyObject *swig_obj[1] ;
48863
48864 if (!args) SWIG_fail;
48865 swig_obj[0] = args;
48866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48867 if (!SWIG_IsOK(res1)) {
48868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48869 }
48870 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48871 {
48872 PyThreadState* __tstate = wxPyBeginAllowThreads();
48873 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48874 wxPyEndAllowThreads(__tstate);
48875 if (PyErr_Occurred()) SWIG_fail;
48876 }
48877 {
48878 resultobj = wxPyMake_wxObject(result, (bool)0);
48879 }
48880 return resultobj;
48881 fail:
48882 return NULL;
48883 }
48884
48885
48886 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48887 PyObject *resultobj = 0;
48888 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48889 wxButton *result = 0 ;
48890 void *argp1 = 0 ;
48891 int res1 = 0 ;
48892 PyObject *swig_obj[1] ;
48893
48894 if (!args) SWIG_fail;
48895 swig_obj[0] = args;
48896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48897 if (!SWIG_IsOK(res1)) {
48898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48899 }
48900 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48901 {
48902 PyThreadState* __tstate = wxPyBeginAllowThreads();
48903 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48904 wxPyEndAllowThreads(__tstate);
48905 if (PyErr_Occurred()) SWIG_fail;
48906 }
48907 {
48908 resultobj = wxPyMake_wxObject(result, (bool)0);
48909 }
48910 return resultobj;
48911 fail:
48912 return NULL;
48913 }
48914
48915
48916 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48917 PyObject *resultobj = 0;
48918 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48919 wxButton *result = 0 ;
48920 void *argp1 = 0 ;
48921 int res1 = 0 ;
48922 PyObject *swig_obj[1] ;
48923
48924 if (!args) SWIG_fail;
48925 swig_obj[0] = args;
48926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48927 if (!SWIG_IsOK(res1)) {
48928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48929 }
48930 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48931 {
48932 PyThreadState* __tstate = wxPyBeginAllowThreads();
48933 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48934 wxPyEndAllowThreads(__tstate);
48935 if (PyErr_Occurred()) SWIG_fail;
48936 }
48937 {
48938 resultobj = wxPyMake_wxObject(result, (bool)0);
48939 }
48940 return resultobj;
48941 fail:
48942 return NULL;
48943 }
48944
48945
48946 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48947 PyObject *obj;
48948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48949 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48950 return SWIG_Py_Void();
48951 }
48952
48953 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48954 return SWIG_Python_InitShadowInstance(args);
48955 }
48956
48957 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48958 PyObject *resultobj = 0;
48959 int arg1 = (int) 0 ;
48960 int arg2 = (int) 0 ;
48961 wxGBPosition *result = 0 ;
48962 int val1 ;
48963 int ecode1 = 0 ;
48964 int val2 ;
48965 int ecode2 = 0 ;
48966 PyObject * obj0 = 0 ;
48967 PyObject * obj1 = 0 ;
48968 char * kwnames[] = {
48969 (char *) "row",(char *) "col", NULL
48970 };
48971
48972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48973 if (obj0) {
48974 ecode1 = SWIG_AsVal_int(obj0, &val1);
48975 if (!SWIG_IsOK(ecode1)) {
48976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48977 }
48978 arg1 = static_cast< int >(val1);
48979 }
48980 if (obj1) {
48981 ecode2 = SWIG_AsVal_int(obj1, &val2);
48982 if (!SWIG_IsOK(ecode2)) {
48983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48984 }
48985 arg2 = static_cast< int >(val2);
48986 }
48987 {
48988 PyThreadState* __tstate = wxPyBeginAllowThreads();
48989 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48990 wxPyEndAllowThreads(__tstate);
48991 if (PyErr_Occurred()) SWIG_fail;
48992 }
48993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48994 return resultobj;
48995 fail:
48996 return NULL;
48997 }
48998
48999
49000 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49001 PyObject *resultobj = 0;
49002 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49003 void *argp1 = 0 ;
49004 int res1 = 0 ;
49005 PyObject *swig_obj[1] ;
49006
49007 if (!args) SWIG_fail;
49008 swig_obj[0] = args;
49009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49010 if (!SWIG_IsOK(res1)) {
49011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49012 }
49013 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49014 {
49015 PyThreadState* __tstate = wxPyBeginAllowThreads();
49016 delete arg1;
49017
49018 wxPyEndAllowThreads(__tstate);
49019 if (PyErr_Occurred()) SWIG_fail;
49020 }
49021 resultobj = SWIG_Py_Void();
49022 return resultobj;
49023 fail:
49024 return NULL;
49025 }
49026
49027
49028 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49029 PyObject *resultobj = 0;
49030 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49031 int result;
49032 void *argp1 = 0 ;
49033 int res1 = 0 ;
49034 PyObject *swig_obj[1] ;
49035
49036 if (!args) SWIG_fail;
49037 swig_obj[0] = args;
49038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49039 if (!SWIG_IsOK(res1)) {
49040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49041 }
49042 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49043 {
49044 PyThreadState* __tstate = wxPyBeginAllowThreads();
49045 result = (int)((wxGBPosition const *)arg1)->GetRow();
49046 wxPyEndAllowThreads(__tstate);
49047 if (PyErr_Occurred()) SWIG_fail;
49048 }
49049 resultobj = SWIG_From_int(static_cast< int >(result));
49050 return resultobj;
49051 fail:
49052 return NULL;
49053 }
49054
49055
49056 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49057 PyObject *resultobj = 0;
49058 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49059 int result;
49060 void *argp1 = 0 ;
49061 int res1 = 0 ;
49062 PyObject *swig_obj[1] ;
49063
49064 if (!args) SWIG_fail;
49065 swig_obj[0] = args;
49066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49067 if (!SWIG_IsOK(res1)) {
49068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49069 }
49070 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49071 {
49072 PyThreadState* __tstate = wxPyBeginAllowThreads();
49073 result = (int)((wxGBPosition const *)arg1)->GetCol();
49074 wxPyEndAllowThreads(__tstate);
49075 if (PyErr_Occurred()) SWIG_fail;
49076 }
49077 resultobj = SWIG_From_int(static_cast< int >(result));
49078 return resultobj;
49079 fail:
49080 return NULL;
49081 }
49082
49083
49084 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49085 PyObject *resultobj = 0;
49086 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49087 int arg2 ;
49088 void *argp1 = 0 ;
49089 int res1 = 0 ;
49090 int val2 ;
49091 int ecode2 = 0 ;
49092 PyObject * obj0 = 0 ;
49093 PyObject * obj1 = 0 ;
49094 char * kwnames[] = {
49095 (char *) "self",(char *) "row", NULL
49096 };
49097
49098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49100 if (!SWIG_IsOK(res1)) {
49101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49102 }
49103 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49104 ecode2 = SWIG_AsVal_int(obj1, &val2);
49105 if (!SWIG_IsOK(ecode2)) {
49106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49107 }
49108 arg2 = static_cast< int >(val2);
49109 {
49110 PyThreadState* __tstate = wxPyBeginAllowThreads();
49111 (arg1)->SetRow(arg2);
49112 wxPyEndAllowThreads(__tstate);
49113 if (PyErr_Occurred()) SWIG_fail;
49114 }
49115 resultobj = SWIG_Py_Void();
49116 return resultobj;
49117 fail:
49118 return NULL;
49119 }
49120
49121
49122 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49123 PyObject *resultobj = 0;
49124 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49125 int arg2 ;
49126 void *argp1 = 0 ;
49127 int res1 = 0 ;
49128 int val2 ;
49129 int ecode2 = 0 ;
49130 PyObject * obj0 = 0 ;
49131 PyObject * obj1 = 0 ;
49132 char * kwnames[] = {
49133 (char *) "self",(char *) "col", NULL
49134 };
49135
49136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49140 }
49141 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49142 ecode2 = SWIG_AsVal_int(obj1, &val2);
49143 if (!SWIG_IsOK(ecode2)) {
49144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49145 }
49146 arg2 = static_cast< int >(val2);
49147 {
49148 PyThreadState* __tstate = wxPyBeginAllowThreads();
49149 (arg1)->SetCol(arg2);
49150 wxPyEndAllowThreads(__tstate);
49151 if (PyErr_Occurred()) SWIG_fail;
49152 }
49153 resultobj = SWIG_Py_Void();
49154 return resultobj;
49155 fail:
49156 return NULL;
49157 }
49158
49159
49160 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49161 PyObject *resultobj = 0;
49162 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49163 PyObject *arg2 = (PyObject *) 0 ;
49164 bool result;
49165 void *argp1 = 0 ;
49166 int res1 = 0 ;
49167 PyObject * obj0 = 0 ;
49168 PyObject * obj1 = 0 ;
49169 char * kwnames[] = {
49170 (char *) "self",(char *) "other", NULL
49171 };
49172
49173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49175 if (!SWIG_IsOK(res1)) {
49176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49177 }
49178 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49179 arg2 = obj1;
49180 {
49181 result = (bool)wxGBPosition___eq__(arg1,arg2);
49182 if (PyErr_Occurred()) SWIG_fail;
49183 }
49184 {
49185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49186 }
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49196 PyObject *arg2 = (PyObject *) 0 ;
49197 bool result;
49198 void *argp1 = 0 ;
49199 int res1 = 0 ;
49200 PyObject * obj0 = 0 ;
49201 PyObject * obj1 = 0 ;
49202 char * kwnames[] = {
49203 (char *) "self",(char *) "other", NULL
49204 };
49205
49206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49208 if (!SWIG_IsOK(res1)) {
49209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49210 }
49211 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49212 arg2 = obj1;
49213 {
49214 result = (bool)wxGBPosition___ne__(arg1,arg2);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 {
49218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49219 }
49220 return resultobj;
49221 fail:
49222 return NULL;
49223 }
49224
49225
49226 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49227 PyObject *resultobj = 0;
49228 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49229 int arg2 = (int) 0 ;
49230 int arg3 = (int) 0 ;
49231 void *argp1 = 0 ;
49232 int res1 = 0 ;
49233 int val2 ;
49234 int ecode2 = 0 ;
49235 int val3 ;
49236 int ecode3 = 0 ;
49237 PyObject * obj0 = 0 ;
49238 PyObject * obj1 = 0 ;
49239 PyObject * obj2 = 0 ;
49240 char * kwnames[] = {
49241 (char *) "self",(char *) "row",(char *) "col", NULL
49242 };
49243
49244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49246 if (!SWIG_IsOK(res1)) {
49247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49248 }
49249 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49250 if (obj1) {
49251 ecode2 = SWIG_AsVal_int(obj1, &val2);
49252 if (!SWIG_IsOK(ecode2)) {
49253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49254 }
49255 arg2 = static_cast< int >(val2);
49256 }
49257 if (obj2) {
49258 ecode3 = SWIG_AsVal_int(obj2, &val3);
49259 if (!SWIG_IsOK(ecode3)) {
49260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49261 }
49262 arg3 = static_cast< int >(val3);
49263 }
49264 {
49265 PyThreadState* __tstate = wxPyBeginAllowThreads();
49266 wxGBPosition_Set(arg1,arg2,arg3);
49267 wxPyEndAllowThreads(__tstate);
49268 if (PyErr_Occurred()) SWIG_fail;
49269 }
49270 resultobj = SWIG_Py_Void();
49271 return resultobj;
49272 fail:
49273 return NULL;
49274 }
49275
49276
49277 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49278 PyObject *resultobj = 0;
49279 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49280 PyObject *result = 0 ;
49281 void *argp1 = 0 ;
49282 int res1 = 0 ;
49283 PyObject *swig_obj[1] ;
49284
49285 if (!args) SWIG_fail;
49286 swig_obj[0] = args;
49287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49288 if (!SWIG_IsOK(res1)) {
49289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49290 }
49291 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 result = (PyObject *)wxGBPosition_Get(arg1);
49295 wxPyEndAllowThreads(__tstate);
49296 if (PyErr_Occurred()) SWIG_fail;
49297 }
49298 resultobj = result;
49299 return resultobj;
49300 fail:
49301 return NULL;
49302 }
49303
49304
49305 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49306 PyObject *obj;
49307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49308 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49309 return SWIG_Py_Void();
49310 }
49311
49312 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49313 return SWIG_Python_InitShadowInstance(args);
49314 }
49315
49316 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49317 PyObject *resultobj = 0;
49318 int arg1 = (int) 1 ;
49319 int arg2 = (int) 1 ;
49320 wxGBSpan *result = 0 ;
49321 int val1 ;
49322 int ecode1 = 0 ;
49323 int val2 ;
49324 int ecode2 = 0 ;
49325 PyObject * obj0 = 0 ;
49326 PyObject * obj1 = 0 ;
49327 char * kwnames[] = {
49328 (char *) "rowspan",(char *) "colspan", NULL
49329 };
49330
49331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49332 if (obj0) {
49333 ecode1 = SWIG_AsVal_int(obj0, &val1);
49334 if (!SWIG_IsOK(ecode1)) {
49335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49336 }
49337 arg1 = static_cast< int >(val1);
49338 }
49339 if (obj1) {
49340 ecode2 = SWIG_AsVal_int(obj1, &val2);
49341 if (!SWIG_IsOK(ecode2)) {
49342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49343 }
49344 arg2 = static_cast< int >(val2);
49345 }
49346 {
49347 PyThreadState* __tstate = wxPyBeginAllowThreads();
49348 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49349 wxPyEndAllowThreads(__tstate);
49350 if (PyErr_Occurred()) SWIG_fail;
49351 }
49352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49353 return resultobj;
49354 fail:
49355 return NULL;
49356 }
49357
49358
49359 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49360 PyObject *resultobj = 0;
49361 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49362 void *argp1 = 0 ;
49363 int res1 = 0 ;
49364 PyObject *swig_obj[1] ;
49365
49366 if (!args) SWIG_fail;
49367 swig_obj[0] = args;
49368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49369 if (!SWIG_IsOK(res1)) {
49370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49371 }
49372 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49373 {
49374 PyThreadState* __tstate = wxPyBeginAllowThreads();
49375 delete arg1;
49376
49377 wxPyEndAllowThreads(__tstate);
49378 if (PyErr_Occurred()) SWIG_fail;
49379 }
49380 resultobj = SWIG_Py_Void();
49381 return resultobj;
49382 fail:
49383 return NULL;
49384 }
49385
49386
49387 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49388 PyObject *resultobj = 0;
49389 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49390 int result;
49391 void *argp1 = 0 ;
49392 int res1 = 0 ;
49393 PyObject *swig_obj[1] ;
49394
49395 if (!args) SWIG_fail;
49396 swig_obj[0] = args;
49397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49398 if (!SWIG_IsOK(res1)) {
49399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49400 }
49401 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49402 {
49403 PyThreadState* __tstate = wxPyBeginAllowThreads();
49404 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49405 wxPyEndAllowThreads(__tstate);
49406 if (PyErr_Occurred()) SWIG_fail;
49407 }
49408 resultobj = SWIG_From_int(static_cast< int >(result));
49409 return resultobj;
49410 fail:
49411 return NULL;
49412 }
49413
49414
49415 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49416 PyObject *resultobj = 0;
49417 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49418 int result;
49419 void *argp1 = 0 ;
49420 int res1 = 0 ;
49421 PyObject *swig_obj[1] ;
49422
49423 if (!args) SWIG_fail;
49424 swig_obj[0] = args;
49425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49426 if (!SWIG_IsOK(res1)) {
49427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49428 }
49429 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49430 {
49431 PyThreadState* __tstate = wxPyBeginAllowThreads();
49432 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49433 wxPyEndAllowThreads(__tstate);
49434 if (PyErr_Occurred()) SWIG_fail;
49435 }
49436 resultobj = SWIG_From_int(static_cast< int >(result));
49437 return resultobj;
49438 fail:
49439 return NULL;
49440 }
49441
49442
49443 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49444 PyObject *resultobj = 0;
49445 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49446 int arg2 ;
49447 void *argp1 = 0 ;
49448 int res1 = 0 ;
49449 int val2 ;
49450 int ecode2 = 0 ;
49451 PyObject * obj0 = 0 ;
49452 PyObject * obj1 = 0 ;
49453 char * kwnames[] = {
49454 (char *) "self",(char *) "rowspan", NULL
49455 };
49456
49457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49459 if (!SWIG_IsOK(res1)) {
49460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49461 }
49462 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49463 ecode2 = SWIG_AsVal_int(obj1, &val2);
49464 if (!SWIG_IsOK(ecode2)) {
49465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49466 }
49467 arg2 = static_cast< int >(val2);
49468 {
49469 PyThreadState* __tstate = wxPyBeginAllowThreads();
49470 (arg1)->SetRowspan(arg2);
49471 wxPyEndAllowThreads(__tstate);
49472 if (PyErr_Occurred()) SWIG_fail;
49473 }
49474 resultobj = SWIG_Py_Void();
49475 return resultobj;
49476 fail:
49477 return NULL;
49478 }
49479
49480
49481 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49482 PyObject *resultobj = 0;
49483 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49484 int arg2 ;
49485 void *argp1 = 0 ;
49486 int res1 = 0 ;
49487 int val2 ;
49488 int ecode2 = 0 ;
49489 PyObject * obj0 = 0 ;
49490 PyObject * obj1 = 0 ;
49491 char * kwnames[] = {
49492 (char *) "self",(char *) "colspan", NULL
49493 };
49494
49495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49497 if (!SWIG_IsOK(res1)) {
49498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49499 }
49500 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49501 ecode2 = SWIG_AsVal_int(obj1, &val2);
49502 if (!SWIG_IsOK(ecode2)) {
49503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49504 }
49505 arg2 = static_cast< int >(val2);
49506 {
49507 PyThreadState* __tstate = wxPyBeginAllowThreads();
49508 (arg1)->SetColspan(arg2);
49509 wxPyEndAllowThreads(__tstate);
49510 if (PyErr_Occurred()) SWIG_fail;
49511 }
49512 resultobj = SWIG_Py_Void();
49513 return resultobj;
49514 fail:
49515 return NULL;
49516 }
49517
49518
49519 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49520 PyObject *resultobj = 0;
49521 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49522 PyObject *arg2 = (PyObject *) 0 ;
49523 bool result;
49524 void *argp1 = 0 ;
49525 int res1 = 0 ;
49526 PyObject * obj0 = 0 ;
49527 PyObject * obj1 = 0 ;
49528 char * kwnames[] = {
49529 (char *) "self",(char *) "other", NULL
49530 };
49531
49532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49534 if (!SWIG_IsOK(res1)) {
49535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49536 }
49537 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49538 arg2 = obj1;
49539 {
49540 result = (bool)wxGBSpan___eq__(arg1,arg2);
49541 if (PyErr_Occurred()) SWIG_fail;
49542 }
49543 {
49544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49545 }
49546 return resultobj;
49547 fail:
49548 return NULL;
49549 }
49550
49551
49552 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49553 PyObject *resultobj = 0;
49554 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49555 PyObject *arg2 = (PyObject *) 0 ;
49556 bool result;
49557 void *argp1 = 0 ;
49558 int res1 = 0 ;
49559 PyObject * obj0 = 0 ;
49560 PyObject * obj1 = 0 ;
49561 char * kwnames[] = {
49562 (char *) "self",(char *) "other", NULL
49563 };
49564
49565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49567 if (!SWIG_IsOK(res1)) {
49568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49569 }
49570 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49571 arg2 = obj1;
49572 {
49573 result = (bool)wxGBSpan___ne__(arg1,arg2);
49574 if (PyErr_Occurred()) SWIG_fail;
49575 }
49576 {
49577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49578 }
49579 return resultobj;
49580 fail:
49581 return NULL;
49582 }
49583
49584
49585 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49586 PyObject *resultobj = 0;
49587 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49588 int arg2 = (int) 1 ;
49589 int arg3 = (int) 1 ;
49590 void *argp1 = 0 ;
49591 int res1 = 0 ;
49592 int val2 ;
49593 int ecode2 = 0 ;
49594 int val3 ;
49595 int ecode3 = 0 ;
49596 PyObject * obj0 = 0 ;
49597 PyObject * obj1 = 0 ;
49598 PyObject * obj2 = 0 ;
49599 char * kwnames[] = {
49600 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49601 };
49602
49603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49605 if (!SWIG_IsOK(res1)) {
49606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49607 }
49608 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49609 if (obj1) {
49610 ecode2 = SWIG_AsVal_int(obj1, &val2);
49611 if (!SWIG_IsOK(ecode2)) {
49612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49613 }
49614 arg2 = static_cast< int >(val2);
49615 }
49616 if (obj2) {
49617 ecode3 = SWIG_AsVal_int(obj2, &val3);
49618 if (!SWIG_IsOK(ecode3)) {
49619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49620 }
49621 arg3 = static_cast< int >(val3);
49622 }
49623 {
49624 PyThreadState* __tstate = wxPyBeginAllowThreads();
49625 wxGBSpan_Set(arg1,arg2,arg3);
49626 wxPyEndAllowThreads(__tstate);
49627 if (PyErr_Occurred()) SWIG_fail;
49628 }
49629 resultobj = SWIG_Py_Void();
49630 return resultobj;
49631 fail:
49632 return NULL;
49633 }
49634
49635
49636 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49637 PyObject *resultobj = 0;
49638 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49639 PyObject *result = 0 ;
49640 void *argp1 = 0 ;
49641 int res1 = 0 ;
49642 PyObject *swig_obj[1] ;
49643
49644 if (!args) SWIG_fail;
49645 swig_obj[0] = args;
49646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49647 if (!SWIG_IsOK(res1)) {
49648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49649 }
49650 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49651 {
49652 PyThreadState* __tstate = wxPyBeginAllowThreads();
49653 result = (PyObject *)wxGBSpan_Get(arg1);
49654 wxPyEndAllowThreads(__tstate);
49655 if (PyErr_Occurred()) SWIG_fail;
49656 }
49657 resultobj = result;
49658 return resultobj;
49659 fail:
49660 return NULL;
49661 }
49662
49663
49664 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49665 PyObject *obj;
49666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49667 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49668 return SWIG_Py_Void();
49669 }
49670
49671 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49672 return SWIG_Python_InitShadowInstance(args);
49673 }
49674
49675 SWIGINTERN int DefaultSpan_set(PyObject *) {
49676 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49677 return 1;
49678 }
49679
49680
49681 SWIGINTERN PyObject *DefaultSpan_get(void) {
49682 PyObject *pyobj = 0;
49683
49684 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49685 return pyobj;
49686 }
49687
49688
49689 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49690 PyObject *resultobj = 0;
49691 wxGBSizerItem *result = 0 ;
49692
49693 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49694 {
49695 PyThreadState* __tstate = wxPyBeginAllowThreads();
49696 result = (wxGBSizerItem *)new wxGBSizerItem();
49697 wxPyEndAllowThreads(__tstate);
49698 if (PyErr_Occurred()) SWIG_fail;
49699 }
49700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49701 return resultobj;
49702 fail:
49703 return NULL;
49704 }
49705
49706
49707 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49708 PyObject *resultobj = 0;
49709 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49710 void *argp1 = 0 ;
49711 int res1 = 0 ;
49712 PyObject *swig_obj[1] ;
49713
49714 if (!args) SWIG_fail;
49715 swig_obj[0] = args;
49716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49717 if (!SWIG_IsOK(res1)) {
49718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49719 }
49720 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 delete arg1;
49724
49725 wxPyEndAllowThreads(__tstate);
49726 if (PyErr_Occurred()) SWIG_fail;
49727 }
49728 resultobj = SWIG_Py_Void();
49729 return resultobj;
49730 fail:
49731 return NULL;
49732 }
49733
49734
49735 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49736 PyObject *resultobj = 0;
49737 wxWindow *arg1 = (wxWindow *) 0 ;
49738 wxGBPosition *arg2 = 0 ;
49739 wxGBSpan *arg3 = 0 ;
49740 int arg4 ;
49741 int arg5 ;
49742 PyObject *arg6 = (PyObject *) NULL ;
49743 wxGBSizerItem *result = 0 ;
49744 void *argp1 = 0 ;
49745 int res1 = 0 ;
49746 wxGBPosition temp2 ;
49747 wxGBSpan temp3 ;
49748 int val4 ;
49749 int ecode4 = 0 ;
49750 int val5 ;
49751 int ecode5 = 0 ;
49752 PyObject * obj0 = 0 ;
49753 PyObject * obj1 = 0 ;
49754 PyObject * obj2 = 0 ;
49755 PyObject * obj3 = 0 ;
49756 PyObject * obj4 = 0 ;
49757 PyObject * obj5 = 0 ;
49758 char * kwnames[] = {
49759 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49760 };
49761
49762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49764 if (!SWIG_IsOK(res1)) {
49765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49766 }
49767 arg1 = reinterpret_cast< wxWindow * >(argp1);
49768 {
49769 arg2 = &temp2;
49770 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49771 }
49772 {
49773 arg3 = &temp3;
49774 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49775 }
49776 ecode4 = SWIG_AsVal_int(obj3, &val4);
49777 if (!SWIG_IsOK(ecode4)) {
49778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49779 }
49780 arg4 = static_cast< int >(val4);
49781 ecode5 = SWIG_AsVal_int(obj4, &val5);
49782 if (!SWIG_IsOK(ecode5)) {
49783 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49784 }
49785 arg5 = static_cast< int >(val5);
49786 if (obj5) {
49787 arg6 = obj5;
49788 }
49789 {
49790 PyThreadState* __tstate = wxPyBeginAllowThreads();
49791 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49792 wxPyEndAllowThreads(__tstate);
49793 if (PyErr_Occurred()) SWIG_fail;
49794 }
49795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49796 return resultobj;
49797 fail:
49798 return NULL;
49799 }
49800
49801
49802 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49803 PyObject *resultobj = 0;
49804 wxSizer *arg1 = (wxSizer *) 0 ;
49805 wxGBPosition *arg2 = 0 ;
49806 wxGBSpan *arg3 = 0 ;
49807 int arg4 ;
49808 int arg5 ;
49809 PyObject *arg6 = (PyObject *) NULL ;
49810 wxGBSizerItem *result = 0 ;
49811 int res1 = 0 ;
49812 wxGBPosition temp2 ;
49813 wxGBSpan temp3 ;
49814 int val4 ;
49815 int ecode4 = 0 ;
49816 int val5 ;
49817 int ecode5 = 0 ;
49818 PyObject * obj0 = 0 ;
49819 PyObject * obj1 = 0 ;
49820 PyObject * obj2 = 0 ;
49821 PyObject * obj3 = 0 ;
49822 PyObject * obj4 = 0 ;
49823 PyObject * obj5 = 0 ;
49824 char * kwnames[] = {
49825 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49826 };
49827
49828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49829 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49830 if (!SWIG_IsOK(res1)) {
49831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49832 }
49833 {
49834 arg2 = &temp2;
49835 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49836 }
49837 {
49838 arg3 = &temp3;
49839 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49840 }
49841 ecode4 = SWIG_AsVal_int(obj3, &val4);
49842 if (!SWIG_IsOK(ecode4)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49844 }
49845 arg4 = static_cast< int >(val4);
49846 ecode5 = SWIG_AsVal_int(obj4, &val5);
49847 if (!SWIG_IsOK(ecode5)) {
49848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49849 }
49850 arg5 = static_cast< int >(val5);
49851 if (obj5) {
49852 arg6 = obj5;
49853 }
49854 {
49855 PyThreadState* __tstate = wxPyBeginAllowThreads();
49856 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49857 wxPyEndAllowThreads(__tstate);
49858 if (PyErr_Occurred()) SWIG_fail;
49859 }
49860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49861 return resultobj;
49862 fail:
49863 return NULL;
49864 }
49865
49866
49867 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49868 PyObject *resultobj = 0;
49869 int arg1 ;
49870 int arg2 ;
49871 wxGBPosition *arg3 = 0 ;
49872 wxGBSpan *arg4 = 0 ;
49873 int arg5 ;
49874 int arg6 ;
49875 PyObject *arg7 = (PyObject *) NULL ;
49876 wxGBSizerItem *result = 0 ;
49877 int val1 ;
49878 int ecode1 = 0 ;
49879 int val2 ;
49880 int ecode2 = 0 ;
49881 wxGBPosition temp3 ;
49882 wxGBSpan temp4 ;
49883 int val5 ;
49884 int ecode5 = 0 ;
49885 int val6 ;
49886 int ecode6 = 0 ;
49887 PyObject * obj0 = 0 ;
49888 PyObject * obj1 = 0 ;
49889 PyObject * obj2 = 0 ;
49890 PyObject * obj3 = 0 ;
49891 PyObject * obj4 = 0 ;
49892 PyObject * obj5 = 0 ;
49893 PyObject * obj6 = 0 ;
49894 char * kwnames[] = {
49895 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49896 };
49897
49898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49899 ecode1 = SWIG_AsVal_int(obj0, &val1);
49900 if (!SWIG_IsOK(ecode1)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49902 }
49903 arg1 = static_cast< int >(val1);
49904 ecode2 = SWIG_AsVal_int(obj1, &val2);
49905 if (!SWIG_IsOK(ecode2)) {
49906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49907 }
49908 arg2 = static_cast< int >(val2);
49909 {
49910 arg3 = &temp3;
49911 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49912 }
49913 {
49914 arg4 = &temp4;
49915 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49916 }
49917 ecode5 = SWIG_AsVal_int(obj4, &val5);
49918 if (!SWIG_IsOK(ecode5)) {
49919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49920 }
49921 arg5 = static_cast< int >(val5);
49922 ecode6 = SWIG_AsVal_int(obj5, &val6);
49923 if (!SWIG_IsOK(ecode6)) {
49924 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49925 }
49926 arg6 = static_cast< int >(val6);
49927 if (obj6) {
49928 arg7 = obj6;
49929 }
49930 {
49931 PyThreadState* __tstate = wxPyBeginAllowThreads();
49932 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49933 wxPyEndAllowThreads(__tstate);
49934 if (PyErr_Occurred()) SWIG_fail;
49935 }
49936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49944 PyObject *resultobj = 0;
49945 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49946 wxGBPosition result;
49947 void *argp1 = 0 ;
49948 int res1 = 0 ;
49949 PyObject *swig_obj[1] ;
49950
49951 if (!args) SWIG_fail;
49952 swig_obj[0] = args;
49953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49954 if (!SWIG_IsOK(res1)) {
49955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49956 }
49957 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49958 {
49959 PyThreadState* __tstate = wxPyBeginAllowThreads();
49960 result = ((wxGBSizerItem const *)arg1)->GetPos();
49961 wxPyEndAllowThreads(__tstate);
49962 if (PyErr_Occurred()) SWIG_fail;
49963 }
49964 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49965 return resultobj;
49966 fail:
49967 return NULL;
49968 }
49969
49970
49971 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49972 PyObject *resultobj = 0;
49973 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49974 wxGBSpan result;
49975 void *argp1 = 0 ;
49976 int res1 = 0 ;
49977 PyObject *swig_obj[1] ;
49978
49979 if (!args) SWIG_fail;
49980 swig_obj[0] = args;
49981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49982 if (!SWIG_IsOK(res1)) {
49983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49984 }
49985 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49986 {
49987 PyThreadState* __tstate = wxPyBeginAllowThreads();
49988 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49989 wxPyEndAllowThreads(__tstate);
49990 if (PyErr_Occurred()) SWIG_fail;
49991 }
49992 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49993 return resultobj;
49994 fail:
49995 return NULL;
49996 }
49997
49998
49999 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50000 PyObject *resultobj = 0;
50001 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50002 wxGBPosition *arg2 = 0 ;
50003 bool result;
50004 void *argp1 = 0 ;
50005 int res1 = 0 ;
50006 wxGBPosition temp2 ;
50007 PyObject * obj0 = 0 ;
50008 PyObject * obj1 = 0 ;
50009 char * kwnames[] = {
50010 (char *) "self",(char *) "pos", NULL
50011 };
50012
50013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50015 if (!SWIG_IsOK(res1)) {
50016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50017 }
50018 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50019 {
50020 arg2 = &temp2;
50021 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50022 }
50023 {
50024 PyThreadState* __tstate = wxPyBeginAllowThreads();
50025 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50026 wxPyEndAllowThreads(__tstate);
50027 if (PyErr_Occurred()) SWIG_fail;
50028 }
50029 {
50030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50031 }
50032 return resultobj;
50033 fail:
50034 return NULL;
50035 }
50036
50037
50038 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50039 PyObject *resultobj = 0;
50040 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50041 wxGBSpan *arg2 = 0 ;
50042 bool result;
50043 void *argp1 = 0 ;
50044 int res1 = 0 ;
50045 wxGBSpan temp2 ;
50046 PyObject * obj0 = 0 ;
50047 PyObject * obj1 = 0 ;
50048 char * kwnames[] = {
50049 (char *) "self",(char *) "span", NULL
50050 };
50051
50052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50054 if (!SWIG_IsOK(res1)) {
50055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50056 }
50057 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50058 {
50059 arg2 = &temp2;
50060 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50061 }
50062 {
50063 PyThreadState* __tstate = wxPyBeginAllowThreads();
50064 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50065 wxPyEndAllowThreads(__tstate);
50066 if (PyErr_Occurred()) SWIG_fail;
50067 }
50068 {
50069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50070 }
50071 return resultobj;
50072 fail:
50073 return NULL;
50074 }
50075
50076
50077 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50078 PyObject *resultobj = 0;
50079 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50080 wxGBSizerItem *arg2 = 0 ;
50081 bool result;
50082 void *argp1 = 0 ;
50083 int res1 = 0 ;
50084 void *argp2 = 0 ;
50085 int res2 = 0 ;
50086 PyObject * obj0 = 0 ;
50087 PyObject * obj1 = 0 ;
50088 char * kwnames[] = {
50089 (char *) "self",(char *) "other", NULL
50090 };
50091
50092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50094 if (!SWIG_IsOK(res1)) {
50095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50096 }
50097 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50099 if (!SWIG_IsOK(res2)) {
50100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50101 }
50102 if (!argp2) {
50103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50104 }
50105 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50106 {
50107 PyThreadState* __tstate = wxPyBeginAllowThreads();
50108 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50109 wxPyEndAllowThreads(__tstate);
50110 if (PyErr_Occurred()) SWIG_fail;
50111 }
50112 {
50113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50114 }
50115 return resultobj;
50116 fail:
50117 return NULL;
50118 }
50119
50120
50121 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50122 PyObject *resultobj = 0;
50123 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50124 wxGBPosition *arg2 = 0 ;
50125 wxGBSpan *arg3 = 0 ;
50126 bool result;
50127 void *argp1 = 0 ;
50128 int res1 = 0 ;
50129 wxGBPosition temp2 ;
50130 wxGBSpan temp3 ;
50131 PyObject * obj0 = 0 ;
50132 PyObject * obj1 = 0 ;
50133 PyObject * obj2 = 0 ;
50134 char * kwnames[] = {
50135 (char *) "self",(char *) "pos",(char *) "span", NULL
50136 };
50137
50138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50140 if (!SWIG_IsOK(res1)) {
50141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50142 }
50143 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50144 {
50145 arg2 = &temp2;
50146 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50147 }
50148 {
50149 arg3 = &temp3;
50150 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50151 }
50152 {
50153 PyThreadState* __tstate = wxPyBeginAllowThreads();
50154 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50155 wxPyEndAllowThreads(__tstate);
50156 if (PyErr_Occurred()) SWIG_fail;
50157 }
50158 {
50159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50160 }
50161 return resultobj;
50162 fail:
50163 return NULL;
50164 }
50165
50166
50167 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50168 PyObject *resultobj = 0;
50169 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50170 wxGBPosition result;
50171 void *argp1 = 0 ;
50172 int res1 = 0 ;
50173 PyObject *swig_obj[1] ;
50174
50175 if (!args) SWIG_fail;
50176 swig_obj[0] = args;
50177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50178 if (!SWIG_IsOK(res1)) {
50179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50180 }
50181 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50182 {
50183 PyThreadState* __tstate = wxPyBeginAllowThreads();
50184 result = wxGBSizerItem_GetEndPos(arg1);
50185 wxPyEndAllowThreads(__tstate);
50186 if (PyErr_Occurred()) SWIG_fail;
50187 }
50188 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50189 return resultobj;
50190 fail:
50191 return NULL;
50192 }
50193
50194
50195 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50196 PyObject *resultobj = 0;
50197 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50198 wxGridBagSizer *result = 0 ;
50199 void *argp1 = 0 ;
50200 int res1 = 0 ;
50201 PyObject *swig_obj[1] ;
50202
50203 if (!args) SWIG_fail;
50204 swig_obj[0] = args;
50205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50206 if (!SWIG_IsOK(res1)) {
50207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50208 }
50209 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50210 {
50211 PyThreadState* __tstate = wxPyBeginAllowThreads();
50212 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50213 wxPyEndAllowThreads(__tstate);
50214 if (PyErr_Occurred()) SWIG_fail;
50215 }
50216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50217 return resultobj;
50218 fail:
50219 return NULL;
50220 }
50221
50222
50223 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50224 PyObject *resultobj = 0;
50225 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50226 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50227 void *argp1 = 0 ;
50228 int res1 = 0 ;
50229 void *argp2 = 0 ;
50230 int res2 = 0 ;
50231 PyObject * obj0 = 0 ;
50232 PyObject * obj1 = 0 ;
50233 char * kwnames[] = {
50234 (char *) "self",(char *) "sizer", NULL
50235 };
50236
50237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50239 if (!SWIG_IsOK(res1)) {
50240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50241 }
50242 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50244 if (!SWIG_IsOK(res2)) {
50245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50246 }
50247 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50248 {
50249 PyThreadState* __tstate = wxPyBeginAllowThreads();
50250 (arg1)->SetGBSizer(arg2);
50251 wxPyEndAllowThreads(__tstate);
50252 if (PyErr_Occurred()) SWIG_fail;
50253 }
50254 resultobj = SWIG_Py_Void();
50255 return resultobj;
50256 fail:
50257 return NULL;
50258 }
50259
50260
50261 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50262 PyObject *obj;
50263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50264 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50265 return SWIG_Py_Void();
50266 }
50267
50268 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50269 return SWIG_Python_InitShadowInstance(args);
50270 }
50271
50272 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50273 PyObject *resultobj = 0;
50274 int arg1 = (int) 0 ;
50275 int arg2 = (int) 0 ;
50276 wxGridBagSizer *result = 0 ;
50277 int val1 ;
50278 int ecode1 = 0 ;
50279 int val2 ;
50280 int ecode2 = 0 ;
50281 PyObject * obj0 = 0 ;
50282 PyObject * obj1 = 0 ;
50283 char * kwnames[] = {
50284 (char *) "vgap",(char *) "hgap", NULL
50285 };
50286
50287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50288 if (obj0) {
50289 ecode1 = SWIG_AsVal_int(obj0, &val1);
50290 if (!SWIG_IsOK(ecode1)) {
50291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50292 }
50293 arg1 = static_cast< int >(val1);
50294 }
50295 if (obj1) {
50296 ecode2 = SWIG_AsVal_int(obj1, &val2);
50297 if (!SWIG_IsOK(ecode2)) {
50298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50299 }
50300 arg2 = static_cast< int >(val2);
50301 }
50302 {
50303 PyThreadState* __tstate = wxPyBeginAllowThreads();
50304 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50305 wxPyEndAllowThreads(__tstate);
50306 if (PyErr_Occurred()) SWIG_fail;
50307 }
50308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50309 return resultobj;
50310 fail:
50311 return NULL;
50312 }
50313
50314
50315 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50316 PyObject *resultobj = 0;
50317 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50318 PyObject *arg2 = (PyObject *) 0 ;
50319 wxGBPosition *arg3 = 0 ;
50320 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50321 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50322 int arg5 = (int) 0 ;
50323 int arg6 = (int) 0 ;
50324 PyObject *arg7 = (PyObject *) NULL ;
50325 wxGBSizerItem *result = 0 ;
50326 void *argp1 = 0 ;
50327 int res1 = 0 ;
50328 wxGBPosition temp3 ;
50329 wxGBSpan temp4 ;
50330 int val5 ;
50331 int ecode5 = 0 ;
50332 int val6 ;
50333 int ecode6 = 0 ;
50334 PyObject * obj0 = 0 ;
50335 PyObject * obj1 = 0 ;
50336 PyObject * obj2 = 0 ;
50337 PyObject * obj3 = 0 ;
50338 PyObject * obj4 = 0 ;
50339 PyObject * obj5 = 0 ;
50340 PyObject * obj6 = 0 ;
50341 char * kwnames[] = {
50342 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50343 };
50344
50345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50347 if (!SWIG_IsOK(res1)) {
50348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50349 }
50350 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50351 arg2 = obj1;
50352 {
50353 arg3 = &temp3;
50354 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50355 }
50356 if (obj3) {
50357 {
50358 arg4 = &temp4;
50359 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50360 }
50361 }
50362 if (obj4) {
50363 ecode5 = SWIG_AsVal_int(obj4, &val5);
50364 if (!SWIG_IsOK(ecode5)) {
50365 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50366 }
50367 arg5 = static_cast< int >(val5);
50368 }
50369 if (obj5) {
50370 ecode6 = SWIG_AsVal_int(obj5, &val6);
50371 if (!SWIG_IsOK(ecode6)) {
50372 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50373 }
50374 arg6 = static_cast< int >(val6);
50375 }
50376 if (obj6) {
50377 arg7 = obj6;
50378 }
50379 {
50380 PyThreadState* __tstate = wxPyBeginAllowThreads();
50381 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50382 wxPyEndAllowThreads(__tstate);
50383 if (PyErr_Occurred()) SWIG_fail;
50384 }
50385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50386 return resultobj;
50387 fail:
50388 return NULL;
50389 }
50390
50391
50392 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50393 PyObject *resultobj = 0;
50394 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50395 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50396 wxGBSizerItem *result = 0 ;
50397 void *argp1 = 0 ;
50398 int res1 = 0 ;
50399 int res2 = 0 ;
50400 PyObject * obj0 = 0 ;
50401 PyObject * obj1 = 0 ;
50402 char * kwnames[] = {
50403 (char *) "self",(char *) "item", NULL
50404 };
50405
50406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50408 if (!SWIG_IsOK(res1)) {
50409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50410 }
50411 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50412 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50413 if (!SWIG_IsOK(res2)) {
50414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50415 }
50416 {
50417 PyThreadState* __tstate = wxPyBeginAllowThreads();
50418 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50419 wxPyEndAllowThreads(__tstate);
50420 if (PyErr_Occurred()) SWIG_fail;
50421 }
50422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50423 return resultobj;
50424 fail:
50425 return NULL;
50426 }
50427
50428
50429 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50430 PyObject *resultobj = 0;
50431 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50432 int arg2 ;
50433 int arg3 ;
50434 wxSize result;
50435 void *argp1 = 0 ;
50436 int res1 = 0 ;
50437 int val2 ;
50438 int ecode2 = 0 ;
50439 int val3 ;
50440 int ecode3 = 0 ;
50441 PyObject * obj0 = 0 ;
50442 PyObject * obj1 = 0 ;
50443 PyObject * obj2 = 0 ;
50444 char * kwnames[] = {
50445 (char *) "self",(char *) "row",(char *) "col", NULL
50446 };
50447
50448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50450 if (!SWIG_IsOK(res1)) {
50451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50452 }
50453 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50454 ecode2 = SWIG_AsVal_int(obj1, &val2);
50455 if (!SWIG_IsOK(ecode2)) {
50456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50457 }
50458 arg2 = static_cast< int >(val2);
50459 ecode3 = SWIG_AsVal_int(obj2, &val3);
50460 if (!SWIG_IsOK(ecode3)) {
50461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50462 }
50463 arg3 = static_cast< int >(val3);
50464 {
50465 PyThreadState* __tstate = wxPyBeginAllowThreads();
50466 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50467 wxPyEndAllowThreads(__tstate);
50468 if (PyErr_Occurred()) SWIG_fail;
50469 }
50470 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50471 return resultobj;
50472 fail:
50473 return NULL;
50474 }
50475
50476
50477 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50478 PyObject *resultobj = 0;
50479 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50480 wxSize result;
50481 void *argp1 = 0 ;
50482 int res1 = 0 ;
50483 PyObject *swig_obj[1] ;
50484
50485 if (!args) SWIG_fail;
50486 swig_obj[0] = args;
50487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50488 if (!SWIG_IsOK(res1)) {
50489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50490 }
50491 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50492 {
50493 PyThreadState* __tstate = wxPyBeginAllowThreads();
50494 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50495 wxPyEndAllowThreads(__tstate);
50496 if (PyErr_Occurred()) SWIG_fail;
50497 }
50498 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50499 return resultobj;
50500 fail:
50501 return NULL;
50502 }
50503
50504
50505 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50506 PyObject *resultobj = 0;
50507 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50508 wxSize *arg2 = 0 ;
50509 void *argp1 = 0 ;
50510 int res1 = 0 ;
50511 wxSize temp2 ;
50512 PyObject * obj0 = 0 ;
50513 PyObject * obj1 = 0 ;
50514 char * kwnames[] = {
50515 (char *) "self",(char *) "sz", NULL
50516 };
50517
50518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50520 if (!SWIG_IsOK(res1)) {
50521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50522 }
50523 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50524 {
50525 arg2 = &temp2;
50526 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50527 }
50528 {
50529 PyThreadState* __tstate = wxPyBeginAllowThreads();
50530 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50531 wxPyEndAllowThreads(__tstate);
50532 if (PyErr_Occurred()) SWIG_fail;
50533 }
50534 resultobj = SWIG_Py_Void();
50535 return resultobj;
50536 fail:
50537 return NULL;
50538 }
50539
50540
50541 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50542 PyObject *resultobj = 0;
50543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50544 wxWindow *arg2 = (wxWindow *) 0 ;
50545 wxGBPosition result;
50546 void *argp1 = 0 ;
50547 int res1 = 0 ;
50548 void *argp2 = 0 ;
50549 int res2 = 0 ;
50550
50551 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50553 if (!SWIG_IsOK(res1)) {
50554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50555 }
50556 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50557 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50558 if (!SWIG_IsOK(res2)) {
50559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50560 }
50561 arg2 = reinterpret_cast< wxWindow * >(argp2);
50562 {
50563 PyThreadState* __tstate = wxPyBeginAllowThreads();
50564 result = (arg1)->GetItemPosition(arg2);
50565 wxPyEndAllowThreads(__tstate);
50566 if (PyErr_Occurred()) SWIG_fail;
50567 }
50568 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50569 return resultobj;
50570 fail:
50571 return NULL;
50572 }
50573
50574
50575 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50576 PyObject *resultobj = 0;
50577 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50578 wxSizer *arg2 = (wxSizer *) 0 ;
50579 wxGBPosition result;
50580 void *argp1 = 0 ;
50581 int res1 = 0 ;
50582 void *argp2 = 0 ;
50583 int res2 = 0 ;
50584
50585 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50587 if (!SWIG_IsOK(res1)) {
50588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50589 }
50590 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50591 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50592 if (!SWIG_IsOK(res2)) {
50593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50594 }
50595 arg2 = reinterpret_cast< wxSizer * >(argp2);
50596 {
50597 PyThreadState* __tstate = wxPyBeginAllowThreads();
50598 result = (arg1)->GetItemPosition(arg2);
50599 wxPyEndAllowThreads(__tstate);
50600 if (PyErr_Occurred()) SWIG_fail;
50601 }
50602 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50603 return resultobj;
50604 fail:
50605 return NULL;
50606 }
50607
50608
50609 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50610 PyObject *resultobj = 0;
50611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50612 size_t arg2 ;
50613 wxGBPosition result;
50614 void *argp1 = 0 ;
50615 int res1 = 0 ;
50616 size_t val2 ;
50617 int ecode2 = 0 ;
50618
50619 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50621 if (!SWIG_IsOK(res1)) {
50622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50623 }
50624 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50625 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50626 if (!SWIG_IsOK(ecode2)) {
50627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50628 }
50629 arg2 = static_cast< size_t >(val2);
50630 {
50631 PyThreadState* __tstate = wxPyBeginAllowThreads();
50632 result = (arg1)->GetItemPosition(arg2);
50633 wxPyEndAllowThreads(__tstate);
50634 if (PyErr_Occurred()) SWIG_fail;
50635 }
50636 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50637 return resultobj;
50638 fail:
50639 return NULL;
50640 }
50641
50642
50643 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50644 int argc;
50645 PyObject *argv[3];
50646
50647 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50648 --argc;
50649 if (argc == 2) {
50650 int _v = 0;
50651 {
50652 void *vptr = 0;
50653 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50654 _v = SWIG_CheckState(res);
50655 }
50656 if (!_v) goto check_1;
50657 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50658 }
50659 check_1:
50660
50661 if (argc == 2) {
50662 int _v = 0;
50663 {
50664 void *vptr = 0;
50665 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50666 _v = SWIG_CheckState(res);
50667 }
50668 if (!_v) goto check_2;
50669 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50670 }
50671 check_2:
50672
50673 if (argc == 2) {
50674 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50675 }
50676
50677 fail:
50678 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50679 return NULL;
50680 }
50681
50682
50683 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50684 PyObject *resultobj = 0;
50685 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50686 wxWindow *arg2 = (wxWindow *) 0 ;
50687 wxGBPosition *arg3 = 0 ;
50688 bool result;
50689 void *argp1 = 0 ;
50690 int res1 = 0 ;
50691 void *argp2 = 0 ;
50692 int res2 = 0 ;
50693 wxGBPosition temp3 ;
50694
50695 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50697 if (!SWIG_IsOK(res1)) {
50698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50699 }
50700 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50701 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50702 if (!SWIG_IsOK(res2)) {
50703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50704 }
50705 arg2 = reinterpret_cast< wxWindow * >(argp2);
50706 {
50707 arg3 = &temp3;
50708 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50709 }
50710 {
50711 PyThreadState* __tstate = wxPyBeginAllowThreads();
50712 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50713 wxPyEndAllowThreads(__tstate);
50714 if (PyErr_Occurred()) SWIG_fail;
50715 }
50716 {
50717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50718 }
50719 return resultobj;
50720 fail:
50721 return NULL;
50722 }
50723
50724
50725 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50726 PyObject *resultobj = 0;
50727 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50728 wxSizer *arg2 = (wxSizer *) 0 ;
50729 wxGBPosition *arg3 = 0 ;
50730 bool result;
50731 void *argp1 = 0 ;
50732 int res1 = 0 ;
50733 void *argp2 = 0 ;
50734 int res2 = 0 ;
50735 wxGBPosition temp3 ;
50736
50737 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50739 if (!SWIG_IsOK(res1)) {
50740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50741 }
50742 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50743 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50744 if (!SWIG_IsOK(res2)) {
50745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50746 }
50747 arg2 = reinterpret_cast< wxSizer * >(argp2);
50748 {
50749 arg3 = &temp3;
50750 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50751 }
50752 {
50753 PyThreadState* __tstate = wxPyBeginAllowThreads();
50754 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50755 wxPyEndAllowThreads(__tstate);
50756 if (PyErr_Occurred()) SWIG_fail;
50757 }
50758 {
50759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50760 }
50761 return resultobj;
50762 fail:
50763 return NULL;
50764 }
50765
50766
50767 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50768 PyObject *resultobj = 0;
50769 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50770 size_t arg2 ;
50771 wxGBPosition *arg3 = 0 ;
50772 bool result;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 size_t val2 ;
50776 int ecode2 = 0 ;
50777 wxGBPosition temp3 ;
50778
50779 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res1)) {
50782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50783 }
50784 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50785 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50786 if (!SWIG_IsOK(ecode2)) {
50787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50788 }
50789 arg2 = static_cast< size_t >(val2);
50790 {
50791 arg3 = &temp3;
50792 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50793 }
50794 {
50795 PyThreadState* __tstate = wxPyBeginAllowThreads();
50796 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50797 wxPyEndAllowThreads(__tstate);
50798 if (PyErr_Occurred()) SWIG_fail;
50799 }
50800 {
50801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50802 }
50803 return resultobj;
50804 fail:
50805 return NULL;
50806 }
50807
50808
50809 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50810 int argc;
50811 PyObject *argv[4];
50812
50813 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50814 --argc;
50815 if (argc == 3) {
50816 int _v = 0;
50817 {
50818 void *vptr = 0;
50819 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50820 _v = SWIG_CheckState(res);
50821 }
50822 if (!_v) goto check_1;
50823 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50824 }
50825 check_1:
50826
50827 if (argc == 3) {
50828 int _v = 0;
50829 {
50830 void *vptr = 0;
50831 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50832 _v = SWIG_CheckState(res);
50833 }
50834 if (!_v) goto check_2;
50835 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50836 }
50837 check_2:
50838
50839 if (argc == 3) {
50840 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50841 }
50842
50843 fail:
50844 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50845 return NULL;
50846 }
50847
50848
50849 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50850 PyObject *resultobj = 0;
50851 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50852 wxWindow *arg2 = (wxWindow *) 0 ;
50853 wxGBSpan result;
50854 void *argp1 = 0 ;
50855 int res1 = 0 ;
50856 void *argp2 = 0 ;
50857 int res2 = 0 ;
50858
50859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50861 if (!SWIG_IsOK(res1)) {
50862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50863 }
50864 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50865 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50866 if (!SWIG_IsOK(res2)) {
50867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50868 }
50869 arg2 = reinterpret_cast< wxWindow * >(argp2);
50870 {
50871 PyThreadState* __tstate = wxPyBeginAllowThreads();
50872 result = (arg1)->GetItemSpan(arg2);
50873 wxPyEndAllowThreads(__tstate);
50874 if (PyErr_Occurred()) SWIG_fail;
50875 }
50876 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50877 return resultobj;
50878 fail:
50879 return NULL;
50880 }
50881
50882
50883 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50884 PyObject *resultobj = 0;
50885 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50886 wxSizer *arg2 = (wxSizer *) 0 ;
50887 wxGBSpan result;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 void *argp2 = 0 ;
50891 int res2 = 0 ;
50892
50893 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50895 if (!SWIG_IsOK(res1)) {
50896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50897 }
50898 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50899 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50900 if (!SWIG_IsOK(res2)) {
50901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50902 }
50903 arg2 = reinterpret_cast< wxSizer * >(argp2);
50904 {
50905 PyThreadState* __tstate = wxPyBeginAllowThreads();
50906 result = (arg1)->GetItemSpan(arg2);
50907 wxPyEndAllowThreads(__tstate);
50908 if (PyErr_Occurred()) SWIG_fail;
50909 }
50910 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50911 return resultobj;
50912 fail:
50913 return NULL;
50914 }
50915
50916
50917 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50918 PyObject *resultobj = 0;
50919 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50920 size_t arg2 ;
50921 wxGBSpan result;
50922 void *argp1 = 0 ;
50923 int res1 = 0 ;
50924 size_t val2 ;
50925 int ecode2 = 0 ;
50926
50927 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50929 if (!SWIG_IsOK(res1)) {
50930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50931 }
50932 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50933 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50934 if (!SWIG_IsOK(ecode2)) {
50935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50936 }
50937 arg2 = static_cast< size_t >(val2);
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 result = (arg1)->GetItemSpan(arg2);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50945 return resultobj;
50946 fail:
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50952 int argc;
50953 PyObject *argv[3];
50954
50955 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50956 --argc;
50957 if (argc == 2) {
50958 int _v = 0;
50959 {
50960 void *vptr = 0;
50961 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50962 _v = SWIG_CheckState(res);
50963 }
50964 if (!_v) goto check_1;
50965 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50966 }
50967 check_1:
50968
50969 if (argc == 2) {
50970 int _v = 0;
50971 {
50972 void *vptr = 0;
50973 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50974 _v = SWIG_CheckState(res);
50975 }
50976 if (!_v) goto check_2;
50977 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50978 }
50979 check_2:
50980
50981 if (argc == 2) {
50982 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50983 }
50984
50985 fail:
50986 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50987 return NULL;
50988 }
50989
50990
50991 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50992 PyObject *resultobj = 0;
50993 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50994 wxWindow *arg2 = (wxWindow *) 0 ;
50995 wxGBSpan *arg3 = 0 ;
50996 bool result;
50997 void *argp1 = 0 ;
50998 int res1 = 0 ;
50999 void *argp2 = 0 ;
51000 int res2 = 0 ;
51001 wxGBSpan temp3 ;
51002
51003 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51005 if (!SWIG_IsOK(res1)) {
51006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51007 }
51008 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51009 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51010 if (!SWIG_IsOK(res2)) {
51011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51012 }
51013 arg2 = reinterpret_cast< wxWindow * >(argp2);
51014 {
51015 arg3 = &temp3;
51016 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51017 }
51018 {
51019 PyThreadState* __tstate = wxPyBeginAllowThreads();
51020 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51021 wxPyEndAllowThreads(__tstate);
51022 if (PyErr_Occurred()) SWIG_fail;
51023 }
51024 {
51025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51026 }
51027 return resultobj;
51028 fail:
51029 return NULL;
51030 }
51031
51032
51033 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51034 PyObject *resultobj = 0;
51035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51036 wxSizer *arg2 = (wxSizer *) 0 ;
51037 wxGBSpan *arg3 = 0 ;
51038 bool result;
51039 void *argp1 = 0 ;
51040 int res1 = 0 ;
51041 void *argp2 = 0 ;
51042 int res2 = 0 ;
51043 wxGBSpan temp3 ;
51044
51045 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51047 if (!SWIG_IsOK(res1)) {
51048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51049 }
51050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51051 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51052 if (!SWIG_IsOK(res2)) {
51053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51054 }
51055 arg2 = reinterpret_cast< wxSizer * >(argp2);
51056 {
51057 arg3 = &temp3;
51058 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51059 }
51060 {
51061 PyThreadState* __tstate = wxPyBeginAllowThreads();
51062 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51063 wxPyEndAllowThreads(__tstate);
51064 if (PyErr_Occurred()) SWIG_fail;
51065 }
51066 {
51067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51068 }
51069 return resultobj;
51070 fail:
51071 return NULL;
51072 }
51073
51074
51075 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51076 PyObject *resultobj = 0;
51077 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51078 size_t arg2 ;
51079 wxGBSpan *arg3 = 0 ;
51080 bool result;
51081 void *argp1 = 0 ;
51082 int res1 = 0 ;
51083 size_t val2 ;
51084 int ecode2 = 0 ;
51085 wxGBSpan temp3 ;
51086
51087 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51089 if (!SWIG_IsOK(res1)) {
51090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51091 }
51092 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51093 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51094 if (!SWIG_IsOK(ecode2)) {
51095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51096 }
51097 arg2 = static_cast< size_t >(val2);
51098 {
51099 arg3 = &temp3;
51100 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51101 }
51102 {
51103 PyThreadState* __tstate = wxPyBeginAllowThreads();
51104 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51105 wxPyEndAllowThreads(__tstate);
51106 if (PyErr_Occurred()) SWIG_fail;
51107 }
51108 {
51109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51110 }
51111 return resultobj;
51112 fail:
51113 return NULL;
51114 }
51115
51116
51117 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51118 int argc;
51119 PyObject *argv[4];
51120
51121 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51122 --argc;
51123 if (argc == 3) {
51124 int _v = 0;
51125 {
51126 void *vptr = 0;
51127 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51128 _v = SWIG_CheckState(res);
51129 }
51130 if (!_v) goto check_1;
51131 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51132 }
51133 check_1:
51134
51135 if (argc == 3) {
51136 int _v = 0;
51137 {
51138 void *vptr = 0;
51139 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51140 _v = SWIG_CheckState(res);
51141 }
51142 if (!_v) goto check_2;
51143 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51144 }
51145 check_2:
51146
51147 if (argc == 3) {
51148 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51149 }
51150
51151 fail:
51152 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51153 return NULL;
51154 }
51155
51156
51157 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51158 PyObject *resultobj = 0;
51159 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51160 wxWindow *arg2 = (wxWindow *) 0 ;
51161 wxGBSizerItem *result = 0 ;
51162 void *argp1 = 0 ;
51163 int res1 = 0 ;
51164 void *argp2 = 0 ;
51165 int res2 = 0 ;
51166
51167 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51169 if (!SWIG_IsOK(res1)) {
51170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51171 }
51172 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51173 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51174 if (!SWIG_IsOK(res2)) {
51175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51176 }
51177 arg2 = reinterpret_cast< wxWindow * >(argp2);
51178 {
51179 PyThreadState* __tstate = wxPyBeginAllowThreads();
51180 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51181 wxPyEndAllowThreads(__tstate);
51182 if (PyErr_Occurred()) SWIG_fail;
51183 }
51184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51185 return resultobj;
51186 fail:
51187 return NULL;
51188 }
51189
51190
51191 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51192 PyObject *resultobj = 0;
51193 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51194 wxSizer *arg2 = (wxSizer *) 0 ;
51195 wxGBSizerItem *result = 0 ;
51196 void *argp1 = 0 ;
51197 int res1 = 0 ;
51198 void *argp2 = 0 ;
51199 int res2 = 0 ;
51200
51201 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51203 if (!SWIG_IsOK(res1)) {
51204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51205 }
51206 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51208 if (!SWIG_IsOK(res2)) {
51209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51210 }
51211 arg2 = reinterpret_cast< wxSizer * >(argp2);
51212 {
51213 PyThreadState* __tstate = wxPyBeginAllowThreads();
51214 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51215 wxPyEndAllowThreads(__tstate);
51216 if (PyErr_Occurred()) SWIG_fail;
51217 }
51218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51219 return resultobj;
51220 fail:
51221 return NULL;
51222 }
51223
51224
51225 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51226 int argc;
51227 PyObject *argv[3];
51228
51229 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51230 --argc;
51231 if (argc == 2) {
51232 int _v = 0;
51233 {
51234 void *vptr = 0;
51235 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51236 _v = SWIG_CheckState(res);
51237 }
51238 if (!_v) goto check_1;
51239 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51240 }
51241 check_1:
51242
51243 if (argc == 2) {
51244 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51245 }
51246
51247 fail:
51248 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51249 return NULL;
51250 }
51251
51252
51253 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51254 PyObject *resultobj = 0;
51255 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51256 wxGBPosition *arg2 = 0 ;
51257 wxGBSizerItem *result = 0 ;
51258 void *argp1 = 0 ;
51259 int res1 = 0 ;
51260 wxGBPosition temp2 ;
51261 PyObject * obj0 = 0 ;
51262 PyObject * obj1 = 0 ;
51263 char * kwnames[] = {
51264 (char *) "self",(char *) "pos", NULL
51265 };
51266
51267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51269 if (!SWIG_IsOK(res1)) {
51270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51271 }
51272 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51273 {
51274 arg2 = &temp2;
51275 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51276 }
51277 {
51278 PyThreadState* __tstate = wxPyBeginAllowThreads();
51279 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51280 wxPyEndAllowThreads(__tstate);
51281 if (PyErr_Occurred()) SWIG_fail;
51282 }
51283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51284 return resultobj;
51285 fail:
51286 return NULL;
51287 }
51288
51289
51290 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51291 PyObject *resultobj = 0;
51292 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51293 wxPoint *arg2 = 0 ;
51294 wxGBSizerItem *result = 0 ;
51295 void *argp1 = 0 ;
51296 int res1 = 0 ;
51297 wxPoint temp2 ;
51298 PyObject * obj0 = 0 ;
51299 PyObject * obj1 = 0 ;
51300 char * kwnames[] = {
51301 (char *) "self",(char *) "pt", NULL
51302 };
51303
51304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51306 if (!SWIG_IsOK(res1)) {
51307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51308 }
51309 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51310 {
51311 arg2 = &temp2;
51312 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51313 }
51314 {
51315 PyThreadState* __tstate = wxPyBeginAllowThreads();
51316 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51317 wxPyEndAllowThreads(__tstate);
51318 if (PyErr_Occurred()) SWIG_fail;
51319 }
51320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51321 return resultobj;
51322 fail:
51323 return NULL;
51324 }
51325
51326
51327 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51328 PyObject *resultobj = 0;
51329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51330 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51331 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51332 bool result;
51333 void *argp1 = 0 ;
51334 int res1 = 0 ;
51335 void *argp2 = 0 ;
51336 int res2 = 0 ;
51337 void *argp3 = 0 ;
51338 int res3 = 0 ;
51339 PyObject * obj0 = 0 ;
51340 PyObject * obj1 = 0 ;
51341 PyObject * obj2 = 0 ;
51342 char * kwnames[] = {
51343 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51344 };
51345
51346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51348 if (!SWIG_IsOK(res1)) {
51349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51350 }
51351 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51353 if (!SWIG_IsOK(res2)) {
51354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51355 }
51356 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51357 if (obj2) {
51358 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51359 if (!SWIG_IsOK(res3)) {
51360 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51361 }
51362 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51363 }
51364 {
51365 PyThreadState* __tstate = wxPyBeginAllowThreads();
51366 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51367 wxPyEndAllowThreads(__tstate);
51368 if (PyErr_Occurred()) SWIG_fail;
51369 }
51370 {
51371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51372 }
51373 return resultobj;
51374 fail:
51375 return NULL;
51376 }
51377
51378
51379 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51380 PyObject *resultobj = 0;
51381 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51382 wxGBPosition *arg2 = 0 ;
51383 wxGBSpan *arg3 = 0 ;
51384 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51385 bool result;
51386 void *argp1 = 0 ;
51387 int res1 = 0 ;
51388 wxGBPosition temp2 ;
51389 wxGBSpan temp3 ;
51390 void *argp4 = 0 ;
51391 int res4 = 0 ;
51392 PyObject * obj0 = 0 ;
51393 PyObject * obj1 = 0 ;
51394 PyObject * obj2 = 0 ;
51395 PyObject * obj3 = 0 ;
51396 char * kwnames[] = {
51397 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51398 };
51399
51400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51402 if (!SWIG_IsOK(res1)) {
51403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51404 }
51405 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51406 {
51407 arg2 = &temp2;
51408 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51409 }
51410 {
51411 arg3 = &temp3;
51412 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51413 }
51414 if (obj3) {
51415 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51416 if (!SWIG_IsOK(res4)) {
51417 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51418 }
51419 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51420 }
51421 {
51422 PyThreadState* __tstate = wxPyBeginAllowThreads();
51423 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51424 wxPyEndAllowThreads(__tstate);
51425 if (PyErr_Occurred()) SWIG_fail;
51426 }
51427 {
51428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51429 }
51430 return resultobj;
51431 fail:
51432 return NULL;
51433 }
51434
51435
51436 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51437 PyObject *obj;
51438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51439 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51440 return SWIG_Py_Void();
51441 }
51442
51443 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51444 return SWIG_Python_InitShadowInstance(args);
51445 }
51446
51447 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51448 PyObject *resultobj = 0;
51449 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51450 wxRelationship arg2 ;
51451 wxWindow *arg3 = (wxWindow *) 0 ;
51452 wxEdge arg4 ;
51453 int arg5 = (int) 0 ;
51454 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51455 void *argp1 = 0 ;
51456 int res1 = 0 ;
51457 int val2 ;
51458 int ecode2 = 0 ;
51459 void *argp3 = 0 ;
51460 int res3 = 0 ;
51461 int val4 ;
51462 int ecode4 = 0 ;
51463 int val5 ;
51464 int ecode5 = 0 ;
51465 int val6 ;
51466 int ecode6 = 0 ;
51467 PyObject * obj0 = 0 ;
51468 PyObject * obj1 = 0 ;
51469 PyObject * obj2 = 0 ;
51470 PyObject * obj3 = 0 ;
51471 PyObject * obj4 = 0 ;
51472 PyObject * obj5 = 0 ;
51473 char * kwnames[] = {
51474 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51475 };
51476
51477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51479 if (!SWIG_IsOK(res1)) {
51480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51481 }
51482 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51483 ecode2 = SWIG_AsVal_int(obj1, &val2);
51484 if (!SWIG_IsOK(ecode2)) {
51485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51486 }
51487 arg2 = static_cast< wxRelationship >(val2);
51488 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51489 if (!SWIG_IsOK(res3)) {
51490 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51491 }
51492 arg3 = reinterpret_cast< wxWindow * >(argp3);
51493 ecode4 = SWIG_AsVal_int(obj3, &val4);
51494 if (!SWIG_IsOK(ecode4)) {
51495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51496 }
51497 arg4 = static_cast< wxEdge >(val4);
51498 if (obj4) {
51499 ecode5 = SWIG_AsVal_int(obj4, &val5);
51500 if (!SWIG_IsOK(ecode5)) {
51501 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51502 }
51503 arg5 = static_cast< int >(val5);
51504 }
51505 if (obj5) {
51506 ecode6 = SWIG_AsVal_int(obj5, &val6);
51507 if (!SWIG_IsOK(ecode6)) {
51508 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51509 }
51510 arg6 = static_cast< int >(val6);
51511 }
51512 {
51513 PyThreadState* __tstate = wxPyBeginAllowThreads();
51514 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51515 wxPyEndAllowThreads(__tstate);
51516 if (PyErr_Occurred()) SWIG_fail;
51517 }
51518 resultobj = SWIG_Py_Void();
51519 return resultobj;
51520 fail:
51521 return NULL;
51522 }
51523
51524
51525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51526 PyObject *resultobj = 0;
51527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51528 wxWindow *arg2 = (wxWindow *) 0 ;
51529 int arg3 = (int) 0 ;
51530 void *argp1 = 0 ;
51531 int res1 = 0 ;
51532 void *argp2 = 0 ;
51533 int res2 = 0 ;
51534 int val3 ;
51535 int ecode3 = 0 ;
51536 PyObject * obj0 = 0 ;
51537 PyObject * obj1 = 0 ;
51538 PyObject * obj2 = 0 ;
51539 char * kwnames[] = {
51540 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51541 };
51542
51543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51545 if (!SWIG_IsOK(res1)) {
51546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51547 }
51548 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51550 if (!SWIG_IsOK(res2)) {
51551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51552 }
51553 arg2 = reinterpret_cast< wxWindow * >(argp2);
51554 if (obj2) {
51555 ecode3 = SWIG_AsVal_int(obj2, &val3);
51556 if (!SWIG_IsOK(ecode3)) {
51557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51558 }
51559 arg3 = static_cast< int >(val3);
51560 }
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 (arg1)->LeftOf(arg2,arg3);
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 resultobj = SWIG_Py_Void();
51568 return resultobj;
51569 fail:
51570 return NULL;
51571 }
51572
51573
51574 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51575 PyObject *resultobj = 0;
51576 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51577 wxWindow *arg2 = (wxWindow *) 0 ;
51578 int arg3 = (int) 0 ;
51579 void *argp1 = 0 ;
51580 int res1 = 0 ;
51581 void *argp2 = 0 ;
51582 int res2 = 0 ;
51583 int val3 ;
51584 int ecode3 = 0 ;
51585 PyObject * obj0 = 0 ;
51586 PyObject * obj1 = 0 ;
51587 PyObject * obj2 = 0 ;
51588 char * kwnames[] = {
51589 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51590 };
51591
51592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51594 if (!SWIG_IsOK(res1)) {
51595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51596 }
51597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51599 if (!SWIG_IsOK(res2)) {
51600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51601 }
51602 arg2 = reinterpret_cast< wxWindow * >(argp2);
51603 if (obj2) {
51604 ecode3 = SWIG_AsVal_int(obj2, &val3);
51605 if (!SWIG_IsOK(ecode3)) {
51606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51607 }
51608 arg3 = static_cast< int >(val3);
51609 }
51610 {
51611 PyThreadState* __tstate = wxPyBeginAllowThreads();
51612 (arg1)->RightOf(arg2,arg3);
51613 wxPyEndAllowThreads(__tstate);
51614 if (PyErr_Occurred()) SWIG_fail;
51615 }
51616 resultobj = SWIG_Py_Void();
51617 return resultobj;
51618 fail:
51619 return NULL;
51620 }
51621
51622
51623 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51624 PyObject *resultobj = 0;
51625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51626 wxWindow *arg2 = (wxWindow *) 0 ;
51627 int arg3 = (int) 0 ;
51628 void *argp1 = 0 ;
51629 int res1 = 0 ;
51630 void *argp2 = 0 ;
51631 int res2 = 0 ;
51632 int val3 ;
51633 int ecode3 = 0 ;
51634 PyObject * obj0 = 0 ;
51635 PyObject * obj1 = 0 ;
51636 PyObject * obj2 = 0 ;
51637 char * kwnames[] = {
51638 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51639 };
51640
51641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51643 if (!SWIG_IsOK(res1)) {
51644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51645 }
51646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51648 if (!SWIG_IsOK(res2)) {
51649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51650 }
51651 arg2 = reinterpret_cast< wxWindow * >(argp2);
51652 if (obj2) {
51653 ecode3 = SWIG_AsVal_int(obj2, &val3);
51654 if (!SWIG_IsOK(ecode3)) {
51655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51656 }
51657 arg3 = static_cast< int >(val3);
51658 }
51659 {
51660 PyThreadState* __tstate = wxPyBeginAllowThreads();
51661 (arg1)->Above(arg2,arg3);
51662 wxPyEndAllowThreads(__tstate);
51663 if (PyErr_Occurred()) SWIG_fail;
51664 }
51665 resultobj = SWIG_Py_Void();
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51673 PyObject *resultobj = 0;
51674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51675 wxWindow *arg2 = (wxWindow *) 0 ;
51676 int arg3 = (int) 0 ;
51677 void *argp1 = 0 ;
51678 int res1 = 0 ;
51679 void *argp2 = 0 ;
51680 int res2 = 0 ;
51681 int val3 ;
51682 int ecode3 = 0 ;
51683 PyObject * obj0 = 0 ;
51684 PyObject * obj1 = 0 ;
51685 PyObject * obj2 = 0 ;
51686 char * kwnames[] = {
51687 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51688 };
51689
51690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51692 if (!SWIG_IsOK(res1)) {
51693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51694 }
51695 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51697 if (!SWIG_IsOK(res2)) {
51698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51699 }
51700 arg2 = reinterpret_cast< wxWindow * >(argp2);
51701 if (obj2) {
51702 ecode3 = SWIG_AsVal_int(obj2, &val3);
51703 if (!SWIG_IsOK(ecode3)) {
51704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51705 }
51706 arg3 = static_cast< int >(val3);
51707 }
51708 {
51709 PyThreadState* __tstate = wxPyBeginAllowThreads();
51710 (arg1)->Below(arg2,arg3);
51711 wxPyEndAllowThreads(__tstate);
51712 if (PyErr_Occurred()) SWIG_fail;
51713 }
51714 resultobj = SWIG_Py_Void();
51715 return resultobj;
51716 fail:
51717 return NULL;
51718 }
51719
51720
51721 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51722 PyObject *resultobj = 0;
51723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51724 wxWindow *arg2 = (wxWindow *) 0 ;
51725 wxEdge arg3 ;
51726 int arg4 = (int) 0 ;
51727 void *argp1 = 0 ;
51728 int res1 = 0 ;
51729 void *argp2 = 0 ;
51730 int res2 = 0 ;
51731 int val3 ;
51732 int ecode3 = 0 ;
51733 int val4 ;
51734 int ecode4 = 0 ;
51735 PyObject * obj0 = 0 ;
51736 PyObject * obj1 = 0 ;
51737 PyObject * obj2 = 0 ;
51738 PyObject * obj3 = 0 ;
51739 char * kwnames[] = {
51740 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51741 };
51742
51743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51745 if (!SWIG_IsOK(res1)) {
51746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51747 }
51748 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51750 if (!SWIG_IsOK(res2)) {
51751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51752 }
51753 arg2 = reinterpret_cast< wxWindow * >(argp2);
51754 ecode3 = SWIG_AsVal_int(obj2, &val3);
51755 if (!SWIG_IsOK(ecode3)) {
51756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51757 }
51758 arg3 = static_cast< wxEdge >(val3);
51759 if (obj3) {
51760 ecode4 = SWIG_AsVal_int(obj3, &val4);
51761 if (!SWIG_IsOK(ecode4)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51763 }
51764 arg4 = static_cast< int >(val4);
51765 }
51766 {
51767 PyThreadState* __tstate = wxPyBeginAllowThreads();
51768 (arg1)->SameAs(arg2,arg3,arg4);
51769 wxPyEndAllowThreads(__tstate);
51770 if (PyErr_Occurred()) SWIG_fail;
51771 }
51772 resultobj = SWIG_Py_Void();
51773 return resultobj;
51774 fail:
51775 return NULL;
51776 }
51777
51778
51779 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51780 PyObject *resultobj = 0;
51781 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51782 wxWindow *arg2 = (wxWindow *) 0 ;
51783 wxEdge arg3 ;
51784 int arg4 ;
51785 void *argp1 = 0 ;
51786 int res1 = 0 ;
51787 void *argp2 = 0 ;
51788 int res2 = 0 ;
51789 int val3 ;
51790 int ecode3 = 0 ;
51791 int val4 ;
51792 int ecode4 = 0 ;
51793 PyObject * obj0 = 0 ;
51794 PyObject * obj1 = 0 ;
51795 PyObject * obj2 = 0 ;
51796 PyObject * obj3 = 0 ;
51797 char * kwnames[] = {
51798 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51799 };
51800
51801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51803 if (!SWIG_IsOK(res1)) {
51804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51805 }
51806 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51808 if (!SWIG_IsOK(res2)) {
51809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51810 }
51811 arg2 = reinterpret_cast< wxWindow * >(argp2);
51812 ecode3 = SWIG_AsVal_int(obj2, &val3);
51813 if (!SWIG_IsOK(ecode3)) {
51814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51815 }
51816 arg3 = static_cast< wxEdge >(val3);
51817 ecode4 = SWIG_AsVal_int(obj3, &val4);
51818 if (!SWIG_IsOK(ecode4)) {
51819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51820 }
51821 arg4 = static_cast< int >(val4);
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 (arg1)->PercentOf(arg2,arg3,arg4);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_Py_Void();
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51836 PyObject *resultobj = 0;
51837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51838 int arg2 ;
51839 void *argp1 = 0 ;
51840 int res1 = 0 ;
51841 int val2 ;
51842 int ecode2 = 0 ;
51843 PyObject * obj0 = 0 ;
51844 PyObject * obj1 = 0 ;
51845 char * kwnames[] = {
51846 (char *) "self",(char *) "val", NULL
51847 };
51848
51849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51851 if (!SWIG_IsOK(res1)) {
51852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51853 }
51854 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51855 ecode2 = SWIG_AsVal_int(obj1, &val2);
51856 if (!SWIG_IsOK(ecode2)) {
51857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51858 }
51859 arg2 = static_cast< int >(val2);
51860 {
51861 PyThreadState* __tstate = wxPyBeginAllowThreads();
51862 (arg1)->Absolute(arg2);
51863 wxPyEndAllowThreads(__tstate);
51864 if (PyErr_Occurred()) SWIG_fail;
51865 }
51866 resultobj = SWIG_Py_Void();
51867 return resultobj;
51868 fail:
51869 return NULL;
51870 }
51871
51872
51873 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51874 PyObject *resultobj = 0;
51875 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51876 void *argp1 = 0 ;
51877 int res1 = 0 ;
51878 PyObject *swig_obj[1] ;
51879
51880 if (!args) SWIG_fail;
51881 swig_obj[0] = args;
51882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51883 if (!SWIG_IsOK(res1)) {
51884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51885 }
51886 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51887 {
51888 PyThreadState* __tstate = wxPyBeginAllowThreads();
51889 (arg1)->Unconstrained();
51890 wxPyEndAllowThreads(__tstate);
51891 if (PyErr_Occurred()) SWIG_fail;
51892 }
51893 resultobj = SWIG_Py_Void();
51894 return resultobj;
51895 fail:
51896 return NULL;
51897 }
51898
51899
51900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51901 PyObject *resultobj = 0;
51902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51903 void *argp1 = 0 ;
51904 int res1 = 0 ;
51905 PyObject *swig_obj[1] ;
51906
51907 if (!args) SWIG_fail;
51908 swig_obj[0] = args;
51909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51910 if (!SWIG_IsOK(res1)) {
51911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51912 }
51913 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51914 {
51915 PyThreadState* __tstate = wxPyBeginAllowThreads();
51916 (arg1)->AsIs();
51917 wxPyEndAllowThreads(__tstate);
51918 if (PyErr_Occurred()) SWIG_fail;
51919 }
51920 resultobj = SWIG_Py_Void();
51921 return resultobj;
51922 fail:
51923 return NULL;
51924 }
51925
51926
51927 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51928 PyObject *resultobj = 0;
51929 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51930 wxWindow *result = 0 ;
51931 void *argp1 = 0 ;
51932 int res1 = 0 ;
51933 PyObject *swig_obj[1] ;
51934
51935 if (!args) SWIG_fail;
51936 swig_obj[0] = args;
51937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51938 if (!SWIG_IsOK(res1)) {
51939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51940 }
51941 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51942 {
51943 PyThreadState* __tstate = wxPyBeginAllowThreads();
51944 result = (wxWindow *)(arg1)->GetOtherWindow();
51945 wxPyEndAllowThreads(__tstate);
51946 if (PyErr_Occurred()) SWIG_fail;
51947 }
51948 {
51949 resultobj = wxPyMake_wxObject(result, 0);
51950 }
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51958 PyObject *resultobj = 0;
51959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51960 wxEdge result;
51961 void *argp1 = 0 ;
51962 int res1 = 0 ;
51963 PyObject *swig_obj[1] ;
51964
51965 if (!args) SWIG_fail;
51966 swig_obj[0] = args;
51967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51968 if (!SWIG_IsOK(res1)) {
51969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51970 }
51971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51972 {
51973 PyThreadState* __tstate = wxPyBeginAllowThreads();
51974 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51975 wxPyEndAllowThreads(__tstate);
51976 if (PyErr_Occurred()) SWIG_fail;
51977 }
51978 resultobj = SWIG_From_int(static_cast< int >(result));
51979 return resultobj;
51980 fail:
51981 return NULL;
51982 }
51983
51984
51985 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51986 PyObject *resultobj = 0;
51987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51988 wxEdge arg2 ;
51989 void *argp1 = 0 ;
51990 int res1 = 0 ;
51991 int val2 ;
51992 int ecode2 = 0 ;
51993 PyObject * obj0 = 0 ;
51994 PyObject * obj1 = 0 ;
51995 char * kwnames[] = {
51996 (char *) "self",(char *) "which", NULL
51997 };
51998
51999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52001 if (!SWIG_IsOK(res1)) {
52002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52003 }
52004 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52005 ecode2 = SWIG_AsVal_int(obj1, &val2);
52006 if (!SWIG_IsOK(ecode2)) {
52007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52008 }
52009 arg2 = static_cast< wxEdge >(val2);
52010 {
52011 PyThreadState* __tstate = wxPyBeginAllowThreads();
52012 (arg1)->SetEdge(arg2);
52013 wxPyEndAllowThreads(__tstate);
52014 if (PyErr_Occurred()) SWIG_fail;
52015 }
52016 resultobj = SWIG_Py_Void();
52017 return resultobj;
52018 fail:
52019 return NULL;
52020 }
52021
52022
52023 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52024 PyObject *resultobj = 0;
52025 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52026 int arg2 ;
52027 void *argp1 = 0 ;
52028 int res1 = 0 ;
52029 int val2 ;
52030 int ecode2 = 0 ;
52031 PyObject * obj0 = 0 ;
52032 PyObject * obj1 = 0 ;
52033 char * kwnames[] = {
52034 (char *) "self",(char *) "v", NULL
52035 };
52036
52037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) 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_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52041 }
52042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52043 ecode2 = SWIG_AsVal_int(obj1, &val2);
52044 if (!SWIG_IsOK(ecode2)) {
52045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52046 }
52047 arg2 = static_cast< int >(val2);
52048 {
52049 PyThreadState* __tstate = wxPyBeginAllowThreads();
52050 (arg1)->SetValue(arg2);
52051 wxPyEndAllowThreads(__tstate);
52052 if (PyErr_Occurred()) SWIG_fail;
52053 }
52054 resultobj = SWIG_Py_Void();
52055 return resultobj;
52056 fail:
52057 return NULL;
52058 }
52059
52060
52061 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52062 PyObject *resultobj = 0;
52063 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52064 int result;
52065 void *argp1 = 0 ;
52066 int res1 = 0 ;
52067 PyObject *swig_obj[1] ;
52068
52069 if (!args) SWIG_fail;
52070 swig_obj[0] = args;
52071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52072 if (!SWIG_IsOK(res1)) {
52073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52074 }
52075 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 result = (int)(arg1)->GetMargin();
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 resultobj = SWIG_From_int(static_cast< int >(result));
52083 return resultobj;
52084 fail:
52085 return NULL;
52086 }
52087
52088
52089 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52090 PyObject *resultobj = 0;
52091 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52092 int arg2 ;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 int val2 ;
52096 int ecode2 = 0 ;
52097 PyObject * obj0 = 0 ;
52098 PyObject * obj1 = 0 ;
52099 char * kwnames[] = {
52100 (char *) "self",(char *) "m", NULL
52101 };
52102
52103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52107 }
52108 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52109 ecode2 = SWIG_AsVal_int(obj1, &val2);
52110 if (!SWIG_IsOK(ecode2)) {
52111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52112 }
52113 arg2 = static_cast< int >(val2);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 (arg1)->SetMargin(arg2);
52117 wxPyEndAllowThreads(__tstate);
52118 if (PyErr_Occurred()) SWIG_fail;
52119 }
52120 resultobj = SWIG_Py_Void();
52121 return resultobj;
52122 fail:
52123 return NULL;
52124 }
52125
52126
52127 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52128 PyObject *resultobj = 0;
52129 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52130 int result;
52131 void *argp1 = 0 ;
52132 int res1 = 0 ;
52133 PyObject *swig_obj[1] ;
52134
52135 if (!args) SWIG_fail;
52136 swig_obj[0] = args;
52137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52138 if (!SWIG_IsOK(res1)) {
52139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52140 }
52141 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52142 {
52143 PyThreadState* __tstate = wxPyBeginAllowThreads();
52144 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52145 wxPyEndAllowThreads(__tstate);
52146 if (PyErr_Occurred()) SWIG_fail;
52147 }
52148 resultobj = SWIG_From_int(static_cast< int >(result));
52149 return resultobj;
52150 fail:
52151 return NULL;
52152 }
52153
52154
52155 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52156 PyObject *resultobj = 0;
52157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52158 int result;
52159 void *argp1 = 0 ;
52160 int res1 = 0 ;
52161 PyObject *swig_obj[1] ;
52162
52163 if (!args) SWIG_fail;
52164 swig_obj[0] = args;
52165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52166 if (!SWIG_IsOK(res1)) {
52167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52168 }
52169 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52170 {
52171 PyThreadState* __tstate = wxPyBeginAllowThreads();
52172 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52173 wxPyEndAllowThreads(__tstate);
52174 if (PyErr_Occurred()) SWIG_fail;
52175 }
52176 resultobj = SWIG_From_int(static_cast< int >(result));
52177 return resultobj;
52178 fail:
52179 return NULL;
52180 }
52181
52182
52183 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52184 PyObject *resultobj = 0;
52185 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52186 int result;
52187 void *argp1 = 0 ;
52188 int res1 = 0 ;
52189 PyObject *swig_obj[1] ;
52190
52191 if (!args) SWIG_fail;
52192 swig_obj[0] = args;
52193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52194 if (!SWIG_IsOK(res1)) {
52195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52196 }
52197 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52198 {
52199 PyThreadState* __tstate = wxPyBeginAllowThreads();
52200 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52201 wxPyEndAllowThreads(__tstate);
52202 if (PyErr_Occurred()) SWIG_fail;
52203 }
52204 resultobj = SWIG_From_int(static_cast< int >(result));
52205 return resultobj;
52206 fail:
52207 return NULL;
52208 }
52209
52210
52211 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52212 PyObject *resultobj = 0;
52213 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52214 bool result;
52215 void *argp1 = 0 ;
52216 int res1 = 0 ;
52217 PyObject *swig_obj[1] ;
52218
52219 if (!args) SWIG_fail;
52220 swig_obj[0] = args;
52221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52222 if (!SWIG_IsOK(res1)) {
52223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52224 }
52225 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52226 {
52227 PyThreadState* __tstate = wxPyBeginAllowThreads();
52228 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52229 wxPyEndAllowThreads(__tstate);
52230 if (PyErr_Occurred()) SWIG_fail;
52231 }
52232 {
52233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52234 }
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52242 PyObject *resultobj = 0;
52243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52244 bool arg2 ;
52245 void *argp1 = 0 ;
52246 int res1 = 0 ;
52247 bool val2 ;
52248 int ecode2 = 0 ;
52249 PyObject * obj0 = 0 ;
52250 PyObject * obj1 = 0 ;
52251 char * kwnames[] = {
52252 (char *) "self",(char *) "d", NULL
52253 };
52254
52255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52257 if (!SWIG_IsOK(res1)) {
52258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52259 }
52260 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52262 if (!SWIG_IsOK(ecode2)) {
52263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52264 }
52265 arg2 = static_cast< bool >(val2);
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 (arg1)->SetDone(arg2);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 resultobj = SWIG_Py_Void();
52273 return resultobj;
52274 fail:
52275 return NULL;
52276 }
52277
52278
52279 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52280 PyObject *resultobj = 0;
52281 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52282 wxRelationship result;
52283 void *argp1 = 0 ;
52284 int res1 = 0 ;
52285 PyObject *swig_obj[1] ;
52286
52287 if (!args) SWIG_fail;
52288 swig_obj[0] = args;
52289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52290 if (!SWIG_IsOK(res1)) {
52291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52292 }
52293 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52294 {
52295 PyThreadState* __tstate = wxPyBeginAllowThreads();
52296 result = (wxRelationship)(arg1)->GetRelationship();
52297 wxPyEndAllowThreads(__tstate);
52298 if (PyErr_Occurred()) SWIG_fail;
52299 }
52300 resultobj = SWIG_From_int(static_cast< int >(result));
52301 return resultobj;
52302 fail:
52303 return NULL;
52304 }
52305
52306
52307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52308 PyObject *resultobj = 0;
52309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52310 wxRelationship arg2 ;
52311 void *argp1 = 0 ;
52312 int res1 = 0 ;
52313 int val2 ;
52314 int ecode2 = 0 ;
52315 PyObject * obj0 = 0 ;
52316 PyObject * obj1 = 0 ;
52317 char * kwnames[] = {
52318 (char *) "self",(char *) "r", NULL
52319 };
52320
52321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52323 if (!SWIG_IsOK(res1)) {
52324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52325 }
52326 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52327 ecode2 = SWIG_AsVal_int(obj1, &val2);
52328 if (!SWIG_IsOK(ecode2)) {
52329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52330 }
52331 arg2 = static_cast< wxRelationship >(val2);
52332 {
52333 PyThreadState* __tstate = wxPyBeginAllowThreads();
52334 (arg1)->SetRelationship(arg2);
52335 wxPyEndAllowThreads(__tstate);
52336 if (PyErr_Occurred()) SWIG_fail;
52337 }
52338 resultobj = SWIG_Py_Void();
52339 return resultobj;
52340 fail:
52341 return NULL;
52342 }
52343
52344
52345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52346 PyObject *resultobj = 0;
52347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52348 wxWindow *arg2 = (wxWindow *) 0 ;
52349 bool result;
52350 void *argp1 = 0 ;
52351 int res1 = 0 ;
52352 void *argp2 = 0 ;
52353 int res2 = 0 ;
52354 PyObject * obj0 = 0 ;
52355 PyObject * obj1 = 0 ;
52356 char * kwnames[] = {
52357 (char *) "self",(char *) "otherW", NULL
52358 };
52359
52360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52362 if (!SWIG_IsOK(res1)) {
52363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52364 }
52365 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52367 if (!SWIG_IsOK(res2)) {
52368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52369 }
52370 arg2 = reinterpret_cast< wxWindow * >(argp2);
52371 {
52372 PyThreadState* __tstate = wxPyBeginAllowThreads();
52373 result = (bool)(arg1)->ResetIfWin(arg2);
52374 wxPyEndAllowThreads(__tstate);
52375 if (PyErr_Occurred()) SWIG_fail;
52376 }
52377 {
52378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52379 }
52380 return resultobj;
52381 fail:
52382 return NULL;
52383 }
52384
52385
52386 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52387 PyObject *resultobj = 0;
52388 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52389 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52390 wxWindow *arg3 = (wxWindow *) 0 ;
52391 bool result;
52392 void *argp1 = 0 ;
52393 int res1 = 0 ;
52394 void *argp2 = 0 ;
52395 int res2 = 0 ;
52396 void *argp3 = 0 ;
52397 int res3 = 0 ;
52398 PyObject * obj0 = 0 ;
52399 PyObject * obj1 = 0 ;
52400 PyObject * obj2 = 0 ;
52401 char * kwnames[] = {
52402 (char *) "self",(char *) "constraints",(char *) "win", NULL
52403 };
52404
52405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52407 if (!SWIG_IsOK(res1)) {
52408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52409 }
52410 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52411 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52412 if (!SWIG_IsOK(res2)) {
52413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52414 }
52415 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52416 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52417 if (!SWIG_IsOK(res3)) {
52418 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52419 }
52420 arg3 = reinterpret_cast< wxWindow * >(argp3);
52421 {
52422 PyThreadState* __tstate = wxPyBeginAllowThreads();
52423 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52424 wxPyEndAllowThreads(__tstate);
52425 if (PyErr_Occurred()) SWIG_fail;
52426 }
52427 {
52428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52429 }
52430 return resultobj;
52431 fail:
52432 return NULL;
52433 }
52434
52435
52436 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52437 PyObject *resultobj = 0;
52438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52439 wxEdge arg2 ;
52440 wxWindow *arg3 = (wxWindow *) 0 ;
52441 wxWindow *arg4 = (wxWindow *) 0 ;
52442 int result;
52443 void *argp1 = 0 ;
52444 int res1 = 0 ;
52445 int val2 ;
52446 int ecode2 = 0 ;
52447 void *argp3 = 0 ;
52448 int res3 = 0 ;
52449 void *argp4 = 0 ;
52450 int res4 = 0 ;
52451 PyObject * obj0 = 0 ;
52452 PyObject * obj1 = 0 ;
52453 PyObject * obj2 = 0 ;
52454 PyObject * obj3 = 0 ;
52455 char * kwnames[] = {
52456 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52457 };
52458
52459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52461 if (!SWIG_IsOK(res1)) {
52462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52463 }
52464 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52465 ecode2 = SWIG_AsVal_int(obj1, &val2);
52466 if (!SWIG_IsOK(ecode2)) {
52467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52468 }
52469 arg2 = static_cast< wxEdge >(val2);
52470 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52471 if (!SWIG_IsOK(res3)) {
52472 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52473 }
52474 arg3 = reinterpret_cast< wxWindow * >(argp3);
52475 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52476 if (!SWIG_IsOK(res4)) {
52477 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52478 }
52479 arg4 = reinterpret_cast< wxWindow * >(argp4);
52480 {
52481 PyThreadState* __tstate = wxPyBeginAllowThreads();
52482 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52483 wxPyEndAllowThreads(__tstate);
52484 if (PyErr_Occurred()) SWIG_fail;
52485 }
52486 resultobj = SWIG_From_int(static_cast< int >(result));
52487 return resultobj;
52488 fail:
52489 return NULL;
52490 }
52491
52492
52493 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52494 PyObject *obj;
52495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52496 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52497 return SWIG_Py_Void();
52498 }
52499
52500 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52501 PyObject *resultobj = 0;
52502 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52503 wxIndividualLayoutConstraint *result = 0 ;
52504 void *argp1 = 0 ;
52505 int res1 = 0 ;
52506 PyObject *swig_obj[1] ;
52507
52508 if (!args) SWIG_fail;
52509 swig_obj[0] = args;
52510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52511 if (!SWIG_IsOK(res1)) {
52512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52513 }
52514 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52515 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52517 return resultobj;
52518 fail:
52519 return NULL;
52520 }
52521
52522
52523 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52524 PyObject *resultobj = 0;
52525 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52526 wxIndividualLayoutConstraint *result = 0 ;
52527 void *argp1 = 0 ;
52528 int res1 = 0 ;
52529 PyObject *swig_obj[1] ;
52530
52531 if (!args) SWIG_fail;
52532 swig_obj[0] = args;
52533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52534 if (!SWIG_IsOK(res1)) {
52535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52536 }
52537 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52538 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52540 return resultobj;
52541 fail:
52542 return NULL;
52543 }
52544
52545
52546 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52547 PyObject *resultobj = 0;
52548 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52549 wxIndividualLayoutConstraint *result = 0 ;
52550 void *argp1 = 0 ;
52551 int res1 = 0 ;
52552 PyObject *swig_obj[1] ;
52553
52554 if (!args) SWIG_fail;
52555 swig_obj[0] = args;
52556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52557 if (!SWIG_IsOK(res1)) {
52558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52559 }
52560 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52561 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52563 return resultobj;
52564 fail:
52565 return NULL;
52566 }
52567
52568
52569 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52570 PyObject *resultobj = 0;
52571 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52572 wxIndividualLayoutConstraint *result = 0 ;
52573 void *argp1 = 0 ;
52574 int res1 = 0 ;
52575 PyObject *swig_obj[1] ;
52576
52577 if (!args) SWIG_fail;
52578 swig_obj[0] = args;
52579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52580 if (!SWIG_IsOK(res1)) {
52581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52582 }
52583 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52584 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52586 return resultobj;
52587 fail:
52588 return NULL;
52589 }
52590
52591
52592 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52593 PyObject *resultobj = 0;
52594 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52595 wxIndividualLayoutConstraint *result = 0 ;
52596 void *argp1 = 0 ;
52597 int res1 = 0 ;
52598 PyObject *swig_obj[1] ;
52599
52600 if (!args) SWIG_fail;
52601 swig_obj[0] = args;
52602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52603 if (!SWIG_IsOK(res1)) {
52604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52605 }
52606 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52607 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52609 return resultobj;
52610 fail:
52611 return NULL;
52612 }
52613
52614
52615 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52616 PyObject *resultobj = 0;
52617 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52618 wxIndividualLayoutConstraint *result = 0 ;
52619 void *argp1 = 0 ;
52620 int res1 = 0 ;
52621 PyObject *swig_obj[1] ;
52622
52623 if (!args) SWIG_fail;
52624 swig_obj[0] = args;
52625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52626 if (!SWIG_IsOK(res1)) {
52627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52628 }
52629 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52630 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52632 return resultobj;
52633 fail:
52634 return NULL;
52635 }
52636
52637
52638 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52639 PyObject *resultobj = 0;
52640 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52641 wxIndividualLayoutConstraint *result = 0 ;
52642 void *argp1 = 0 ;
52643 int res1 = 0 ;
52644 PyObject *swig_obj[1] ;
52645
52646 if (!args) SWIG_fail;
52647 swig_obj[0] = args;
52648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52649 if (!SWIG_IsOK(res1)) {
52650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52651 }
52652 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52653 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52655 return resultobj;
52656 fail:
52657 return NULL;
52658 }
52659
52660
52661 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52662 PyObject *resultobj = 0;
52663 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52664 wxIndividualLayoutConstraint *result = 0 ;
52665 void *argp1 = 0 ;
52666 int res1 = 0 ;
52667 PyObject *swig_obj[1] ;
52668
52669 if (!args) SWIG_fail;
52670 swig_obj[0] = args;
52671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52674 }
52675 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52676 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52678 return resultobj;
52679 fail:
52680 return NULL;
52681 }
52682
52683
52684 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52685 PyObject *resultobj = 0;
52686 wxLayoutConstraints *result = 0 ;
52687
52688 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52689 {
52690 PyThreadState* __tstate = wxPyBeginAllowThreads();
52691 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52692 wxPyEndAllowThreads(__tstate);
52693 if (PyErr_Occurred()) SWIG_fail;
52694 }
52695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52696 return resultobj;
52697 fail:
52698 return NULL;
52699 }
52700
52701
52702 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52703 PyObject *resultobj = 0;
52704 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52705 void *argp1 = 0 ;
52706 int res1 = 0 ;
52707 PyObject *swig_obj[1] ;
52708
52709 if (!args) SWIG_fail;
52710 swig_obj[0] = args;
52711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52712 if (!SWIG_IsOK(res1)) {
52713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52714 }
52715 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52716 {
52717 PyThreadState* __tstate = wxPyBeginAllowThreads();
52718 delete arg1;
52719
52720 wxPyEndAllowThreads(__tstate);
52721 if (PyErr_Occurred()) SWIG_fail;
52722 }
52723 resultobj = SWIG_Py_Void();
52724 return resultobj;
52725 fail:
52726 return NULL;
52727 }
52728
52729
52730 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52731 PyObject *resultobj = 0;
52732 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52733 wxWindow *arg2 = (wxWindow *) 0 ;
52734 int *arg3 = (int *) 0 ;
52735 bool result;
52736 void *argp1 = 0 ;
52737 int res1 = 0 ;
52738 void *argp2 = 0 ;
52739 int res2 = 0 ;
52740 int temp3 ;
52741 int res3 = SWIG_TMPOBJ ;
52742 PyObject * obj0 = 0 ;
52743 PyObject * obj1 = 0 ;
52744 char * kwnames[] = {
52745 (char *) "self",(char *) "win", NULL
52746 };
52747
52748 arg3 = &temp3;
52749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52751 if (!SWIG_IsOK(res1)) {
52752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52753 }
52754 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52756 if (!SWIG_IsOK(res2)) {
52757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52758 }
52759 arg2 = reinterpret_cast< wxWindow * >(argp2);
52760 {
52761 PyThreadState* __tstate = wxPyBeginAllowThreads();
52762 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52763 wxPyEndAllowThreads(__tstate);
52764 if (PyErr_Occurred()) SWIG_fail;
52765 }
52766 {
52767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52768 }
52769 if (SWIG_IsTmpObj(res3)) {
52770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52771 } else {
52772 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52774 }
52775 return resultobj;
52776 fail:
52777 return NULL;
52778 }
52779
52780
52781 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52782 PyObject *resultobj = 0;
52783 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52784 bool result;
52785 void *argp1 = 0 ;
52786 int res1 = 0 ;
52787 PyObject *swig_obj[1] ;
52788
52789 if (!args) SWIG_fail;
52790 swig_obj[0] = args;
52791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52792 if (!SWIG_IsOK(res1)) {
52793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52794 }
52795 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52796 {
52797 PyThreadState* __tstate = wxPyBeginAllowThreads();
52798 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52799 wxPyEndAllowThreads(__tstate);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 {
52803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52804 }
52805 return resultobj;
52806 fail:
52807 return NULL;
52808 }
52809
52810
52811 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52812 PyObject *obj;
52813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52814 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52815 return SWIG_Py_Void();
52816 }
52817
52818 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52819 return SWIG_Python_InitShadowInstance(args);
52820 }
52821
52822 static PyMethodDef SwigMethods[] = {
52823 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52824 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52825 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52826 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52827 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52828 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52829 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52830 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52831 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52833 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52844 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52845 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52846 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52848 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52849 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52850 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52851 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52852 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52853 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52854 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52856 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52862 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52863 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52864 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52865 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52866 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52867 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52868 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52870 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52878 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52879 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52880 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52885 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52886 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52888 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52890 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52892 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52894 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52896 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52898 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52899 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52901 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52903 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52904 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52905 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52906 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52925 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52926 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52927 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52928 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52929 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52930 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52931 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52932 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52934 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52935 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52936 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52941 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52942 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52943 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52944 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52951 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52958 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52959 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52960 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52961 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52963 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52964 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52965 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52967 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52968 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52969 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52970 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52975 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52976 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52977 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52978 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52979 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52980 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52983 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52984 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52985 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52987 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52988 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52990 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52991 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52992 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52993 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52994 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52995 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52996 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52997 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52998 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52999 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53000 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53005 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53011 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53012 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53013 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53014 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53016 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53019 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53021 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53024 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53025 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53026 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53029 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53031 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53035 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53036 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53037 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53041 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53046 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53047 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53048 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53049 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53050 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53051 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53052 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53059 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53060 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53062 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53063 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53064 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53070 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53071 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53073 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53074 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53075 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53076 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53077 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53078 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53079 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53080 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53082 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53083 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53084 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53085 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53086 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53087 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53088 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53089 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53091 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53100 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53112 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53113 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53128 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53129 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53130 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53131 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53134 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53136 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53138 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53140 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53142 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53145 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53146 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53147 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53148 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53150 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53167 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53168 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53174 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53175 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53176 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53177 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53178 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53179 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53180 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53181 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53182 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53183 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53185 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53186 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53188 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53189 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53190 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53191 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53192 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53194 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53195 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53197 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53198 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53200 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53201 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53202 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53203 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53204 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53206 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53207 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53208 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53210 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53211 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53212 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53213 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53216 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53220 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53224 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53225 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53226 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53227 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53229 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53230 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53232 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53234 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53236 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53238 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53239 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53240 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53242 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53243 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53245 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53246 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53247 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53249 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53250 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53253 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53255 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53256 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53257 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53259 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53261 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53262 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53264 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53265 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53266 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53268 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53269 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53270 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53271 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53274 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53275 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53278 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53279 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53281 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53282 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53285 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53286 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53288 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53294 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53295 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53296 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53297 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53298 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53299 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53300 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53301 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53302 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53303 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53304 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53305 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53306 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53307 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53308 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53309 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53310 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53311 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53312 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53313 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53314 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53315 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53316 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53317 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53319 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53320 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53321 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53322 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53323 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53324 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53325 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53326 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53327 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53328 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53329 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53330 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53331 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53332 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53333 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53334 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53335 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53336 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53337 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53338 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53339 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53340 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53341 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53342 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53343 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53344 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53345 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53346 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53347 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53348 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53349 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53350 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53352 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53353 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53355 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53356 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53357 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53358 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53360 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53361 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53362 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53363 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53364 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53365 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53366 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53367 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53368 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53370 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53371 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53372 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53373 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53374 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53375 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53376 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53377 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53378 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53379 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53380 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53381 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53382 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53383 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53384 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53385 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53386 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53387 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53388 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53389 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53390 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53391 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53392 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53393 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53394 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53395 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53399 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53400 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53403 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53404 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53405 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53406 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53407 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53410 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53411 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53414 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53415 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53417 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53418 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53420 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53423 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53427 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53429 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53430 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53432 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53433 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53434 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53436 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53437 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53438 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53440 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53441 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53443 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53444 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53445 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53446 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53447 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53450 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53452 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53454 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53455 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53456 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53459 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53460 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53461 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53463 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53464 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53467 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53468 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53469 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53470 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53471 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53472 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53474 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53475 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53476 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53477 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53478 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53479 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53480 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53481 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53487 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53489 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53491 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53492 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53493 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53494 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53495 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53496 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53498 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53499 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53500 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53501 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53502 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53503 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53506 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53507 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53508 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53511 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53512 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53513 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53514 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53515 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53517 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53519 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53522 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53524 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53525 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53527 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53528 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53529 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53531 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53532 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53535 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53537 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53538 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53539 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53541 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53543 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53545 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53546 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53548 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53549 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53551 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53553 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53554 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53555 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53557 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53559 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53560 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53561 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53563 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53565 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53566 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53567 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53568 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53570 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53572 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53574 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53576 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53577 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53579 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53580 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53581 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53582 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53583 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53584 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53585 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53586 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53588 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53590 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53592 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53594 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53596 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53598 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53599 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53600 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53601 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53602 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53603 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53609 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53610 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53611 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53612 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53613 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53614 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53615 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53617 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53619 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53620 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53622 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53623 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53624 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53625 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53627 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53628 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53629 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53630 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53632 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53633 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53635 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53636 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53637 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53639 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53641 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53642 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53643 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53644 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53645 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53647 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53648 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53649 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53650 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53652 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53653 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53654 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53655 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53656 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53657 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53658 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53659 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53660 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53661 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53663 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53666 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53667 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53668 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53670 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53672 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53674 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53676 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53677 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53687 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53688 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53692 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53693 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53694 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53695 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53696 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53697 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53698 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53699 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53700 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53701 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53702 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53703 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53704 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53705 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53706 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53708 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53709 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53712 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53713 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53718 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53719 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53722 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53723 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53724 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53725 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53728 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53729 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53730 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53732 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53734 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53735 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53736 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53738 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53740 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53742 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53745 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53746 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53747 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53748 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53749 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53750 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53754 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53755 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53756 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53757 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53764 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53770 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53771 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53772 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53773 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53774 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53776 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53786 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53787 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53788 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53789 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53792 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53793 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53794 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53795 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53797 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53798 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53802 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53808 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53809 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53810 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53811 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53813 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53814 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53816 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53819 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53821 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53822 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53823 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53832 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53836 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53837 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53839 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53849 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53850 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53851 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53852 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53856 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53859 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53861 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53864 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53866 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53867 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53870 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53872 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53873 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53874 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53875 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53876 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53881 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53882 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53883 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53885 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53886 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53887 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53889 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53891 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53892 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53893 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53895 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53896 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53899 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53907 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53914 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53922 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53925 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53926 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53939 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53941 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53943 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53944 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53946 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53948 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53949 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53951 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53952 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53953 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53957 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53976 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53977 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53979 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53981 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53982 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53983 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53985 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53986 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53989 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53990 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53992 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53993 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53995 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53998 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53999 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54001 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54003 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54005 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54006 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54008 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54009 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54012 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54014 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54016 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54018 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54021 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54023 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54024 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54025 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54027 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54028 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54029 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54031 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54033 { (char *)"Control_GetLabelText", _wrap_Control_GetLabelText, METH_VARARGS, NULL},
54034 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54036 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54038 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54039 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54043 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54047 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54048 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54050 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54054 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54056 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54058 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54059 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54060 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54061 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54065 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54066 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54067 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54068 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54070 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54071 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54076 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54077 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54078 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54079 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54080 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54082 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54084 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54086 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54087 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54089 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54091 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54094 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54095 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54096 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54098 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54099 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54100 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54114 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54115 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54116 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54117 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54118 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54119 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54125 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54126 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54130 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54131 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54133 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54134 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54136 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54138 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54139 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54141 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54142 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54143 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54149 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54150 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54151 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54152 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54153 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54154 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54161 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54163 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54164 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54165 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54166 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54167 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54168 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54170 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54174 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54175 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54176 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54177 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54178 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54179 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54180 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54182 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54183 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54184 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54190 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54191 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54192 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54194 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54195 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54196 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54202 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54203 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54204 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54205 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54206 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54210 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54211 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54216 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54217 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54219 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54220 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54225 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54227 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54228 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54229 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54230 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54231 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54236 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54237 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54246 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54247 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54248 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54249 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54252 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54254 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54255 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54256 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54257 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54259 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54264 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54265 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54266 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54267 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54268 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54269 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54270 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54271 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54272 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54273 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54274 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54276 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54277 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54278 { NULL, NULL, 0, NULL }
54279 };
54280
54281
54282 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54283
54284 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54285 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54286 }
54287 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54288 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54289 }
54290 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54291 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54292 }
54293 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54294 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54295 }
54296 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54297 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54298 }
54299 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54300 return (void *)((wxSizer *) ((wxGridSizer *) x));
54301 }
54302 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54303 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54304 }
54305 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54306 return (void *)((wxSizer *) ((wxPySizer *) x));
54307 }
54308 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54309 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54310 }
54311 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54312 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54313 }
54314 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54316 }
54317 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54318 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54319 }
54320 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54321 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54322 }
54323 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54325 }
54326 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54328 }
54329 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54330 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54331 }
54332 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54333 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54334 }
54335 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54337 }
54338 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54339 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54340 }
54341 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54342 return (void *)((wxEvent *) ((wxPyEvent *) x));
54343 }
54344 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54345 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54346 }
54347 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54348 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54349 }
54350 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54352 }
54353 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54355 }
54356 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54358 }
54359 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54360 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54361 }
54362 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54363 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54364 }
54365 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54366 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54367 }
54368 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54369 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54370 }
54371 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54373 }
54374 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54375 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54376 }
54377 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54378 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54379 }
54380 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54382 }
54383 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54384 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54385 }
54386 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54387 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54388 }
54389 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54390 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54391 }
54392 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54393 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54394 }
54395 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54396 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54397 }
54398 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54399 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54400 }
54401 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54402 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54403 }
54404 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54405 return (void *)((wxEvent *) ((wxShowEvent *) x));
54406 }
54407 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54408 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54409 }
54410 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54411 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54412 }
54413 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54415 }
54416 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54417 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54418 }
54419 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54420 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54421 }
54422 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54423 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54424 }
54425 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54426 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54427 }
54428 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54429 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54430 }
54431 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54432 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54433 }
54434 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54435 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54436 }
54437 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54438 return (void *)((wxControl *) ((wxControlWithItems *) x));
54439 }
54440 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54441 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54442 }
54443 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54444 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54445 }
54446 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54447 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54448 }
54449 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54450 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54451 }
54452 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54453 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54454 }
54455 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54456 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54457 }
54458 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54459 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54460 }
54461 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54462 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54463 }
54464 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54465 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54466 }
54467 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54468 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54469 }
54470 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54471 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54472 }
54473 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54474 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54475 }
54476 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54477 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54478 }
54479 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54480 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54481 }
54482 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54483 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54484 }
54485 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54486 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54487 }
54488 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54489 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54490 }
54491 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54492 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54493 }
54494 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54495 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54496 }
54497 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54498 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54499 }
54500 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54501 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54502 }
54503 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54504 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54505 }
54506 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54507 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54508 }
54509 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54510 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54511 }
54512 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54513 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54514 }
54515 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54516 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54517 }
54518 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54519 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54520 }
54521 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54522 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54523 }
54524 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54525 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54526 }
54527 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54528 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54529 }
54530 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54532 }
54533 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54535 }
54536 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) ((wxSizerItem *) x));
54538 }
54539 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54541 }
54542 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54544 }
54545 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54547 }
54548 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54550 }
54551 static void *_p_wxSizerTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) ((wxSizer *) x));
54553 }
54554 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54556 }
54557 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54559 }
54560 static void *_p_wxEventTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) ((wxEvent *) x));
54562 }
54563 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54565 }
54566 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54568 }
54569 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54571 }
54572 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54574 }
54575 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54577 }
54578 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54580 }
54581 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54583 }
54584 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54586 }
54587 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54589 }
54590 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54592 }
54593 static void *_p_wxControlTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54595 }
54596 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54598 }
54599 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) ((wxFSFile *) x));
54601 }
54602 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54604 }
54605 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54607 }
54608 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54610 }
54611 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54613 }
54614 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) ((wxMenuItem *) x));
54616 }
54617 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54619 }
54620 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54622 }
54623 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54625 }
54626 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54628 }
54629 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54631 }
54632 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54634 }
54635 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54637 }
54638 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54640 }
54641 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54643 }
54644 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54646 }
54647 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54649 }
54650 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54652 }
54653 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54655 }
54656 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54658 }
54659 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54661 }
54662 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54664 }
54665 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54667 }
54668 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54670 }
54671 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54673 }
54674 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) ((wxImageHandler *) x));
54676 }
54677 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54679 }
54680 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54682 }
54683 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) ((wxEvtHandler *) x));
54685 }
54686 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54688 }
54689 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54691 }
54692 static void *_p_wxImageTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) ((wxImage *) x));
54694 }
54695 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54696 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54697 }
54698 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54700 }
54701 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54702 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54703 }
54704 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54705 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54706 }
54707 static void *_p_wxWindowTo_p_wxObject(void *x) {
54708 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54709 }
54710 static void *_p_wxMenuTo_p_wxObject(void *x) {
54711 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54712 }
54713 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54714 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54715 }
54716 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54717 return (void *)((wxObject *) ((wxFileSystem *) x));
54718 }
54719 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54720 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54721 }
54722 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54723 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54724 }
54725 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54726 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54727 }
54728 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54729 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54730 }
54731 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54732 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54733 }
54734 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54735 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54736 }
54737 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54739 }
54740 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54741 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54742 }
54743 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54744 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54745 }
54746 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54747 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54748 }
54749 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54750 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54751 }
54752 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54753 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54754 }
54755 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54756 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54757 }
54758 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54759 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54760 }
54761 static void *_p_wxControlTo_p_wxWindow(void *x) {
54762 return (void *)((wxWindow *) ((wxControl *) x));
54763 }
54764 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54765 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54766 }
54767 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54768 return (void *)((wxWindow *) ((wxMenuBar *) x));
54769 }
54770 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54771 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54772 }
54773 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54774 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54775 }
54776 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54777 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54778 }
54779 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54780 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54781 }
54782 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54783 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54784 }
54785 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54786 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54787 }
54788 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54789 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54790 }
54791 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54792 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54793 }
54794 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54795 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54796 }
54797 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54798 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54799 }
54800 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54801 return (void *)((wxValidator *) ((wxPyValidator *) x));
54802 }
54803 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54805 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};
54806 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54934
54935 static swig_type_info *swig_type_initial[] = {
54936 &_swigt__p_buffer,
54937 &_swigt__p_char,
54938 &_swigt__p_form_ops_t,
54939 &_swigt__p_int,
54940 &_swigt__p_long,
54941 &_swigt__p_unsigned_char,
54942 &_swigt__p_unsigned_int,
54943 &_swigt__p_unsigned_long,
54944 &_swigt__p_wxANIHandler,
54945 &_swigt__p_wxAcceleratorEntry,
54946 &_swigt__p_wxAcceleratorTable,
54947 &_swigt__p_wxActivateEvent,
54948 &_swigt__p_wxAppTraits,
54949 &_swigt__p_wxArrayString,
54950 &_swigt__p_wxBMPHandler,
54951 &_swigt__p_wxBitmap,
54952 &_swigt__p_wxBoxSizer,
54953 &_swigt__p_wxButton,
54954 &_swigt__p_wxCURHandler,
54955 &_swigt__p_wxCaret,
54956 &_swigt__p_wxChildFocusEvent,
54957 &_swigt__p_wxClipboardTextEvent,
54958 &_swigt__p_wxCloseEvent,
54959 &_swigt__p_wxColour,
54960 &_swigt__p_wxCommandEvent,
54961 &_swigt__p_wxContextMenuEvent,
54962 &_swigt__p_wxControl,
54963 &_swigt__p_wxControlWithItems,
54964 &_swigt__p_wxCursor,
54965 &_swigt__p_wxDC,
54966 &_swigt__p_wxDateEvent,
54967 &_swigt__p_wxDateTime,
54968 &_swigt__p_wxDisplayChangedEvent,
54969 &_swigt__p_wxDropFilesEvent,
54970 &_swigt__p_wxDuplexMode,
54971 &_swigt__p_wxEraseEvent,
54972 &_swigt__p_wxEvent,
54973 &_swigt__p_wxEventLoop,
54974 &_swigt__p_wxEventLoopActivator,
54975 &_swigt__p_wxEvtHandler,
54976 &_swigt__p_wxFSFile,
54977 &_swigt__p_wxFileSystem,
54978 &_swigt__p_wxFileSystemHandler,
54979 &_swigt__p_wxFlexGridSizer,
54980 &_swigt__p_wxFocusEvent,
54981 &_swigt__p_wxFont,
54982 &_swigt__p_wxFrame,
54983 &_swigt__p_wxGBPosition,
54984 &_swigt__p_wxGBSizerItem,
54985 &_swigt__p_wxGBSpan,
54986 &_swigt__p_wxGIFHandler,
54987 &_swigt__p_wxGridBagSizer,
54988 &_swigt__p_wxGridSizer,
54989 &_swigt__p_wxHelpEvent__Origin,
54990 &_swigt__p_wxICOHandler,
54991 &_swigt__p_wxIconizeEvent,
54992 &_swigt__p_wxIdleEvent,
54993 &_swigt__p_wxImage,
54994 &_swigt__p_wxImageHandler,
54995 &_swigt__p_wxImageHistogram,
54996 &_swigt__p_wxImage_HSVValue,
54997 &_swigt__p_wxImage_RGBValue,
54998 &_swigt__p_wxIndividualLayoutConstraint,
54999 &_swigt__p_wxInitDialogEvent,
55000 &_swigt__p_wxInputStream,
55001 &_swigt__p_wxInternetFSHandler,
55002 &_swigt__p_wxItemContainer,
55003 &_swigt__p_wxJPEGHandler,
55004 &_swigt__p_wxKeyEvent,
55005 &_swigt__p_wxLayoutConstraints,
55006 &_swigt__p_wxMaximizeEvent,
55007 &_swigt__p_wxMemoryFSHandler,
55008 &_swigt__p_wxMenu,
55009 &_swigt__p_wxMenuBar,
55010 &_swigt__p_wxMenuBarBase,
55011 &_swigt__p_wxMenuEvent,
55012 &_swigt__p_wxMenuItem,
55013 &_swigt__p_wxMouseCaptureChangedEvent,
55014 &_swigt__p_wxMouseEvent,
55015 &_swigt__p_wxMoveEvent,
55016 &_swigt__p_wxNavigationKeyEvent,
55017 &_swigt__p_wxNcPaintEvent,
55018 &_swigt__p_wxNotifyEvent,
55019 &_swigt__p_wxObject,
55020 &_swigt__p_wxOutputStream,
55021 &_swigt__p_wxPCXHandler,
55022 &_swigt__p_wxPNGHandler,
55023 &_swigt__p_wxPNMHandler,
55024 &_swigt__p_wxPaintEvent,
55025 &_swigt__p_wxPaletteChangedEvent,
55026 &_swigt__p_wxPaperSize,
55027 &_swigt__p_wxPoint,
55028 &_swigt__p_wxPoint2D,
55029 &_swigt__p_wxPropagateOnce,
55030 &_swigt__p_wxPropagationDisabler,
55031 &_swigt__p_wxPyApp,
55032 &_swigt__p_wxPyCommandEvent,
55033 &_swigt__p_wxPyDropTarget,
55034 &_swigt__p_wxPyEvent,
55035 &_swigt__p_wxPyFileSystemHandler,
55036 &_swigt__p_wxPyImageHandler,
55037 &_swigt__p_wxPyInputStream,
55038 &_swigt__p_wxPySizer,
55039 &_swigt__p_wxPyValidator,
55040 &_swigt__p_wxQuantize,
55041 &_swigt__p_wxQueryNewPaletteEvent,
55042 &_swigt__p_wxRealPoint,
55043 &_swigt__p_wxRect,
55044 &_swigt__p_wxRegion,
55045 &_swigt__p_wxScrollEvent,
55046 &_swigt__p_wxScrollWinEvent,
55047 &_swigt__p_wxSetCursorEvent,
55048 &_swigt__p_wxShowEvent,
55049 &_swigt__p_wxSize,
55050 &_swigt__p_wxSizeEvent,
55051 &_swigt__p_wxSizer,
55052 &_swigt__p_wxSizerItem,
55053 &_swigt__p_wxStaticBox,
55054 &_swigt__p_wxStaticBoxSizer,
55055 &_swigt__p_wxStdDialogButtonSizer,
55056 &_swigt__p_wxSysColourChangedEvent,
55057 &_swigt__p_wxTIFFHandler,
55058 &_swigt__p_wxToolTip,
55059 &_swigt__p_wxUpdateUIEvent,
55060 &_swigt__p_wxValidator,
55061 &_swigt__p_wxVisualAttributes,
55062 &_swigt__p_wxWindow,
55063 &_swigt__p_wxWindowCreateEvent,
55064 &_swigt__p_wxWindowDestroyEvent,
55065 &_swigt__p_wxXPMHandler,
55066 &_swigt__p_wxZipFSHandler,
55067 };
55068
55069 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55083 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}};
55084 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55085 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}};
55086 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55087 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}};
55088 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55093 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}};
55094 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55095 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}};
55096 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55108 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}};
55109 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55111 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}};
55112 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}};
55113 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55121 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}};
55122 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55123 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}};
55124 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55127 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}};
55128 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55135 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}};
55136 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55139 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55184 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}};
55185 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}};
55186 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55193 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}};
55194 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55195 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}};
55196 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55200
55201 static swig_cast_info *swig_cast_initial[] = {
55202 _swigc__p_buffer,
55203 _swigc__p_char,
55204 _swigc__p_form_ops_t,
55205 _swigc__p_int,
55206 _swigc__p_long,
55207 _swigc__p_unsigned_char,
55208 _swigc__p_unsigned_int,
55209 _swigc__p_unsigned_long,
55210 _swigc__p_wxANIHandler,
55211 _swigc__p_wxAcceleratorEntry,
55212 _swigc__p_wxAcceleratorTable,
55213 _swigc__p_wxActivateEvent,
55214 _swigc__p_wxAppTraits,
55215 _swigc__p_wxArrayString,
55216 _swigc__p_wxBMPHandler,
55217 _swigc__p_wxBitmap,
55218 _swigc__p_wxBoxSizer,
55219 _swigc__p_wxButton,
55220 _swigc__p_wxCURHandler,
55221 _swigc__p_wxCaret,
55222 _swigc__p_wxChildFocusEvent,
55223 _swigc__p_wxClipboardTextEvent,
55224 _swigc__p_wxCloseEvent,
55225 _swigc__p_wxColour,
55226 _swigc__p_wxCommandEvent,
55227 _swigc__p_wxContextMenuEvent,
55228 _swigc__p_wxControl,
55229 _swigc__p_wxControlWithItems,
55230 _swigc__p_wxCursor,
55231 _swigc__p_wxDC,
55232 _swigc__p_wxDateEvent,
55233 _swigc__p_wxDateTime,
55234 _swigc__p_wxDisplayChangedEvent,
55235 _swigc__p_wxDropFilesEvent,
55236 _swigc__p_wxDuplexMode,
55237 _swigc__p_wxEraseEvent,
55238 _swigc__p_wxEvent,
55239 _swigc__p_wxEventLoop,
55240 _swigc__p_wxEventLoopActivator,
55241 _swigc__p_wxEvtHandler,
55242 _swigc__p_wxFSFile,
55243 _swigc__p_wxFileSystem,
55244 _swigc__p_wxFileSystemHandler,
55245 _swigc__p_wxFlexGridSizer,
55246 _swigc__p_wxFocusEvent,
55247 _swigc__p_wxFont,
55248 _swigc__p_wxFrame,
55249 _swigc__p_wxGBPosition,
55250 _swigc__p_wxGBSizerItem,
55251 _swigc__p_wxGBSpan,
55252 _swigc__p_wxGIFHandler,
55253 _swigc__p_wxGridBagSizer,
55254 _swigc__p_wxGridSizer,
55255 _swigc__p_wxHelpEvent__Origin,
55256 _swigc__p_wxICOHandler,
55257 _swigc__p_wxIconizeEvent,
55258 _swigc__p_wxIdleEvent,
55259 _swigc__p_wxImage,
55260 _swigc__p_wxImageHandler,
55261 _swigc__p_wxImageHistogram,
55262 _swigc__p_wxImage_HSVValue,
55263 _swigc__p_wxImage_RGBValue,
55264 _swigc__p_wxIndividualLayoutConstraint,
55265 _swigc__p_wxInitDialogEvent,
55266 _swigc__p_wxInputStream,
55267 _swigc__p_wxInternetFSHandler,
55268 _swigc__p_wxItemContainer,
55269 _swigc__p_wxJPEGHandler,
55270 _swigc__p_wxKeyEvent,
55271 _swigc__p_wxLayoutConstraints,
55272 _swigc__p_wxMaximizeEvent,
55273 _swigc__p_wxMemoryFSHandler,
55274 _swigc__p_wxMenu,
55275 _swigc__p_wxMenuBar,
55276 _swigc__p_wxMenuBarBase,
55277 _swigc__p_wxMenuEvent,
55278 _swigc__p_wxMenuItem,
55279 _swigc__p_wxMouseCaptureChangedEvent,
55280 _swigc__p_wxMouseEvent,
55281 _swigc__p_wxMoveEvent,
55282 _swigc__p_wxNavigationKeyEvent,
55283 _swigc__p_wxNcPaintEvent,
55284 _swigc__p_wxNotifyEvent,
55285 _swigc__p_wxObject,
55286 _swigc__p_wxOutputStream,
55287 _swigc__p_wxPCXHandler,
55288 _swigc__p_wxPNGHandler,
55289 _swigc__p_wxPNMHandler,
55290 _swigc__p_wxPaintEvent,
55291 _swigc__p_wxPaletteChangedEvent,
55292 _swigc__p_wxPaperSize,
55293 _swigc__p_wxPoint,
55294 _swigc__p_wxPoint2D,
55295 _swigc__p_wxPropagateOnce,
55296 _swigc__p_wxPropagationDisabler,
55297 _swigc__p_wxPyApp,
55298 _swigc__p_wxPyCommandEvent,
55299 _swigc__p_wxPyDropTarget,
55300 _swigc__p_wxPyEvent,
55301 _swigc__p_wxPyFileSystemHandler,
55302 _swigc__p_wxPyImageHandler,
55303 _swigc__p_wxPyInputStream,
55304 _swigc__p_wxPySizer,
55305 _swigc__p_wxPyValidator,
55306 _swigc__p_wxQuantize,
55307 _swigc__p_wxQueryNewPaletteEvent,
55308 _swigc__p_wxRealPoint,
55309 _swigc__p_wxRect,
55310 _swigc__p_wxRegion,
55311 _swigc__p_wxScrollEvent,
55312 _swigc__p_wxScrollWinEvent,
55313 _swigc__p_wxSetCursorEvent,
55314 _swigc__p_wxShowEvent,
55315 _swigc__p_wxSize,
55316 _swigc__p_wxSizeEvent,
55317 _swigc__p_wxSizer,
55318 _swigc__p_wxSizerItem,
55319 _swigc__p_wxStaticBox,
55320 _swigc__p_wxStaticBoxSizer,
55321 _swigc__p_wxStdDialogButtonSizer,
55322 _swigc__p_wxSysColourChangedEvent,
55323 _swigc__p_wxTIFFHandler,
55324 _swigc__p_wxToolTip,
55325 _swigc__p_wxUpdateUIEvent,
55326 _swigc__p_wxValidator,
55327 _swigc__p_wxVisualAttributes,
55328 _swigc__p_wxWindow,
55329 _swigc__p_wxWindowCreateEvent,
55330 _swigc__p_wxWindowDestroyEvent,
55331 _swigc__p_wxXPMHandler,
55332 _swigc__p_wxZipFSHandler,
55333 };
55334
55335
55336 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55337
55338 static swig_const_info swig_const_table[] = {
55339 {0, 0, 0, 0.0, 0, 0}};
55340
55341 #ifdef __cplusplus
55342 }
55343 #endif
55344 /* -----------------------------------------------------------------------------
55345 * Type initialization:
55346 * This problem is tough by the requirement that no dynamic
55347 * memory is used. Also, since swig_type_info structures store pointers to
55348 * swig_cast_info structures and swig_cast_info structures store pointers back
55349 * to swig_type_info structures, we need some lookup code at initialization.
55350 * The idea is that swig generates all the structures that are needed.
55351 * The runtime then collects these partially filled structures.
55352 * The SWIG_InitializeModule function takes these initial arrays out of
55353 * swig_module, and does all the lookup, filling in the swig_module.types
55354 * array with the correct data and linking the correct swig_cast_info
55355 * structures together.
55356 *
55357 * The generated swig_type_info structures are assigned staticly to an initial
55358 * array. We just loop though that array, and handle each type individually.
55359 * First we lookup if this type has been already loaded, and if so, use the
55360 * loaded structure instead of the generated one. Then we have to fill in the
55361 * cast linked list. The cast data is initially stored in something like a
55362 * two-dimensional array. Each row corresponds to a type (there are the same
55363 * number of rows as there are in the swig_type_initial array). Each entry in
55364 * a column is one of the swig_cast_info structures for that type.
55365 * The cast_initial array is actually an array of arrays, because each row has
55366 * a variable number of columns. So to actually build the cast linked list,
55367 * we find the array of casts associated with the type, and loop through it
55368 * adding the casts to the list. The one last trick we need to do is making
55369 * sure the type pointer in the swig_cast_info struct is correct.
55370 *
55371 * First off, we lookup the cast->type name to see if it is already loaded.
55372 * There are three cases to handle:
55373 * 1) If the cast->type has already been loaded AND the type we are adding
55374 * casting info to has not been loaded (it is in this module), THEN we
55375 * replace the cast->type pointer with the type pointer that has already
55376 * been loaded.
55377 * 2) If BOTH types (the one we are adding casting info to, and the
55378 * cast->type) are loaded, THEN the cast info has already been loaded by
55379 * the previous module so we just ignore it.
55380 * 3) Finally, if cast->type has not already been loaded, then we add that
55381 * swig_cast_info to the linked list (because the cast->type) pointer will
55382 * be correct.
55383 * ----------------------------------------------------------------------------- */
55384
55385 #ifdef __cplusplus
55386 extern "C" {
55387 #if 0
55388 } /* c-mode */
55389 #endif
55390 #endif
55391
55392 #if 0
55393 #define SWIGRUNTIME_DEBUG
55394 #endif
55395
55396 SWIGRUNTIME void
55397 SWIG_InitializeModule(void *clientdata) {
55398 size_t i;
55399 swig_module_info *module_head;
55400 static int init_run = 0;
55401
55402 clientdata = clientdata;
55403
55404 if (init_run) return;
55405 init_run = 1;
55406
55407 /* Initialize the swig_module */
55408 swig_module.type_initial = swig_type_initial;
55409 swig_module.cast_initial = swig_cast_initial;
55410
55411 /* Try and load any already created modules */
55412 module_head = SWIG_GetModule(clientdata);
55413 if (module_head) {
55414 swig_module.next = module_head->next;
55415 module_head->next = &swig_module;
55416 } else {
55417 /* This is the first module loaded */
55418 swig_module.next = &swig_module;
55419 SWIG_SetModule(clientdata, &swig_module);
55420 }
55421
55422 /* Now work on filling in swig_module.types */
55423 #ifdef SWIGRUNTIME_DEBUG
55424 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55425 #endif
55426 for (i = 0; i < swig_module.size; ++i) {
55427 swig_type_info *type = 0;
55428 swig_type_info *ret;
55429 swig_cast_info *cast;
55430
55431 #ifdef SWIGRUNTIME_DEBUG
55432 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55433 #endif
55434
55435 /* if there is another module already loaded */
55436 if (swig_module.next != &swig_module) {
55437 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55438 }
55439 if (type) {
55440 /* Overwrite clientdata field */
55441 #ifdef SWIGRUNTIME_DEBUG
55442 printf("SWIG_InitializeModule: found type %s\n", type->name);
55443 #endif
55444 if (swig_module.type_initial[i]->clientdata) {
55445 type->clientdata = swig_module.type_initial[i]->clientdata;
55446 #ifdef SWIGRUNTIME_DEBUG
55447 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55448 #endif
55449 }
55450 } else {
55451 type = swig_module.type_initial[i];
55452 }
55453
55454 /* Insert casting types */
55455 cast = swig_module.cast_initial[i];
55456 while (cast->type) {
55457 /* Don't need to add information already in the list */
55458 ret = 0;
55459 #ifdef SWIGRUNTIME_DEBUG
55460 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55461 #endif
55462 if (swig_module.next != &swig_module) {
55463 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55464 #ifdef SWIGRUNTIME_DEBUG
55465 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55466 #endif
55467 }
55468 if (ret) {
55469 if (type == swig_module.type_initial[i]) {
55470 #ifdef SWIGRUNTIME_DEBUG
55471 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55472 #endif
55473 cast->type = ret;
55474 ret = 0;
55475 } else {
55476 /* Check for casting already in the list */
55477 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55478 #ifdef SWIGRUNTIME_DEBUG
55479 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55480 #endif
55481 if (!ocast) ret = 0;
55482 }
55483 }
55484
55485 if (!ret) {
55486 #ifdef SWIGRUNTIME_DEBUG
55487 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55488 #endif
55489 if (type->cast) {
55490 type->cast->prev = cast;
55491 cast->next = type->cast;
55492 }
55493 type->cast = cast;
55494 }
55495 cast++;
55496 }
55497 /* Set entry in modules->types array equal to the type */
55498 swig_module.types[i] = type;
55499 }
55500 swig_module.types[i] = 0;
55501
55502 #ifdef SWIGRUNTIME_DEBUG
55503 printf("**** SWIG_InitializeModule: Cast List ******\n");
55504 for (i = 0; i < swig_module.size; ++i) {
55505 int j = 0;
55506 swig_cast_info *cast = swig_module.cast_initial[i];
55507 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55508 while (cast->type) {
55509 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55510 cast++;
55511 ++j;
55512 }
55513 printf("---- Total casts: %d\n",j);
55514 }
55515 printf("**** SWIG_InitializeModule: Cast List ******\n");
55516 #endif
55517 }
55518
55519 /* This function will propagate the clientdata field of type to
55520 * any new swig_type_info structures that have been added into the list
55521 * of equivalent types. It is like calling
55522 * SWIG_TypeClientData(type, clientdata) a second time.
55523 */
55524 SWIGRUNTIME void
55525 SWIG_PropagateClientData(void) {
55526 size_t i;
55527 swig_cast_info *equiv;
55528 static int init_run = 0;
55529
55530 if (init_run) return;
55531 init_run = 1;
55532
55533 for (i = 0; i < swig_module.size; i++) {
55534 if (swig_module.types[i]->clientdata) {
55535 equiv = swig_module.types[i]->cast;
55536 while (equiv) {
55537 if (!equiv->converter) {
55538 if (equiv->type && !equiv->type->clientdata)
55539 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55540 }
55541 equiv = equiv->next;
55542 }
55543 }
55544 }
55545 }
55546
55547 #ifdef __cplusplus
55548 #if 0
55549 {
55550 /* c-mode */
55551 #endif
55552 }
55553 #endif
55554
55555
55556
55557 #ifdef __cplusplus
55558 extern "C" {
55559 #endif
55560
55561 /* Python-specific SWIG API */
55562 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55563 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55564 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55565
55566 /* -----------------------------------------------------------------------------
55567 * global variable support code.
55568 * ----------------------------------------------------------------------------- */
55569
55570 typedef struct swig_globalvar {
55571 char *name; /* Name of global variable */
55572 PyObject *(*get_attr)(void); /* Return the current value */
55573 int (*set_attr)(PyObject *); /* Set the value */
55574 struct swig_globalvar *next;
55575 } swig_globalvar;
55576
55577 typedef struct swig_varlinkobject {
55578 PyObject_HEAD
55579 swig_globalvar *vars;
55580 } swig_varlinkobject;
55581
55582 SWIGINTERN PyObject *
55583 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55584 return PyString_FromString("<Swig global variables>");
55585 }
55586
55587 SWIGINTERN PyObject *
55588 swig_varlink_str(swig_varlinkobject *v) {
55589 PyObject *str = PyString_FromString("(");
55590 swig_globalvar *var;
55591 for (var = v->vars; var; var=var->next) {
55592 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55593 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55594 }
55595 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55596 return str;
55597 }
55598
55599 SWIGINTERN int
55600 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55601 PyObject *str = swig_varlink_str(v);
55602 fprintf(fp,"Swig global variables ");
55603 fprintf(fp,"%s\n", PyString_AsString(str));
55604 Py_DECREF(str);
55605 return 0;
55606 }
55607
55608 SWIGINTERN void
55609 swig_varlink_dealloc(swig_varlinkobject *v) {
55610 swig_globalvar *var = v->vars;
55611 while (var) {
55612 swig_globalvar *n = var->next;
55613 free(var->name);
55614 free(var);
55615 var = n;
55616 }
55617 }
55618
55619 SWIGINTERN PyObject *
55620 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55621 PyObject *res = NULL;
55622 swig_globalvar *var = v->vars;
55623 while (var) {
55624 if (strcmp(var->name,n) == 0) {
55625 res = (*var->get_attr)();
55626 break;
55627 }
55628 var = var->next;
55629 }
55630 if (res == NULL && !PyErr_Occurred()) {
55631 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55632 }
55633 return res;
55634 }
55635
55636 SWIGINTERN int
55637 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55638 int res = 1;
55639 swig_globalvar *var = v->vars;
55640 while (var) {
55641 if (strcmp(var->name,n) == 0) {
55642 res = (*var->set_attr)(p);
55643 break;
55644 }
55645 var = var->next;
55646 }
55647 if (res == 1 && !PyErr_Occurred()) {
55648 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55649 }
55650 return res;
55651 }
55652
55653 SWIGINTERN PyTypeObject*
55654 swig_varlink_type(void) {
55655 static char varlink__doc__[] = "Swig var link object";
55656 static PyTypeObject varlink_type;
55657 static int type_init = 0;
55658 if (!type_init) {
55659 const PyTypeObject tmp
55660 = {
55661 PyObject_HEAD_INIT(NULL)
55662 0, /* Number of items in variable part (ob_size) */
55663 (char *)"swigvarlink", /* Type name (tp_name) */
55664 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55665 0, /* Itemsize (tp_itemsize) */
55666 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55667 (printfunc) swig_varlink_print, /* Print (tp_print) */
55668 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55669 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55670 0, /* tp_compare */
55671 (reprfunc) swig_varlink_repr, /* tp_repr */
55672 0, /* tp_as_number */
55673 0, /* tp_as_sequence */
55674 0, /* tp_as_mapping */
55675 0, /* tp_hash */
55676 0, /* tp_call */
55677 (reprfunc)swig_varlink_str, /* tp_str */
55678 0, /* tp_getattro */
55679 0, /* tp_setattro */
55680 0, /* tp_as_buffer */
55681 0, /* tp_flags */
55682 varlink__doc__, /* tp_doc */
55683 0, /* tp_traverse */
55684 0, /* tp_clear */
55685 0, /* tp_richcompare */
55686 0, /* tp_weaklistoffset */
55687 #if PY_VERSION_HEX >= 0x02020000
55688 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55689 #endif
55690 #if PY_VERSION_HEX >= 0x02030000
55691 0, /* tp_del */
55692 #endif
55693 #ifdef COUNT_ALLOCS
55694 0,0,0,0 /* tp_alloc -> tp_next */
55695 #endif
55696 };
55697 varlink_type = tmp;
55698 varlink_type.ob_type = &PyType_Type;
55699 type_init = 1;
55700 }
55701 return &varlink_type;
55702 }
55703
55704 /* Create a variable linking object for use later */
55705 SWIGINTERN PyObject *
55706 SWIG_Python_newvarlink(void) {
55707 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55708 if (result) {
55709 result->vars = 0;
55710 }
55711 return ((PyObject*) result);
55712 }
55713
55714 SWIGINTERN void
55715 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55716 swig_varlinkobject *v = (swig_varlinkobject *) p;
55717 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55718 if (gv) {
55719 size_t size = strlen(name)+1;
55720 gv->name = (char *)malloc(size);
55721 if (gv->name) {
55722 strncpy(gv->name,name,size);
55723 gv->get_attr = get_attr;
55724 gv->set_attr = set_attr;
55725 gv->next = v->vars;
55726 }
55727 }
55728 v->vars = gv;
55729 }
55730
55731 SWIGINTERN PyObject *
55732 SWIG_globals() {
55733 static PyObject *_SWIG_globals = 0;
55734 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55735 return _SWIG_globals;
55736 }
55737
55738 /* -----------------------------------------------------------------------------
55739 * constants/methods manipulation
55740 * ----------------------------------------------------------------------------- */
55741
55742 /* Install Constants */
55743 SWIGINTERN void
55744 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55745 PyObject *obj = 0;
55746 size_t i;
55747 for (i = 0; constants[i].type; ++i) {
55748 switch(constants[i].type) {
55749 case SWIG_PY_POINTER:
55750 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55751 break;
55752 case SWIG_PY_BINARY:
55753 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55754 break;
55755 default:
55756 obj = 0;
55757 break;
55758 }
55759 if (obj) {
55760 PyDict_SetItemString(d, constants[i].name, obj);
55761 Py_DECREF(obj);
55762 }
55763 }
55764 }
55765
55766 /* -----------------------------------------------------------------------------*/
55767 /* Fix SwigMethods to carry the callback ptrs when needed */
55768 /* -----------------------------------------------------------------------------*/
55769
55770 SWIGINTERN void
55771 SWIG_Python_FixMethods(PyMethodDef *methods,
55772 swig_const_info *const_table,
55773 swig_type_info **types,
55774 swig_type_info **types_initial) {
55775 size_t i;
55776 for (i = 0; methods[i].ml_name; ++i) {
55777 const char *c = methods[i].ml_doc;
55778 if (c && (c = strstr(c, "swig_ptr: "))) {
55779 int j;
55780 swig_const_info *ci = 0;
55781 const char *name = c + 10;
55782 for (j = 0; const_table[j].type; ++j) {
55783 if (strncmp(const_table[j].name, name,
55784 strlen(const_table[j].name)) == 0) {
55785 ci = &(const_table[j]);
55786 break;
55787 }
55788 }
55789 if (ci) {
55790 size_t shift = (ci->ptype) - types;
55791 swig_type_info *ty = types_initial[shift];
55792 size_t ldoc = (c - methods[i].ml_doc);
55793 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55794 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55795 if (ndoc) {
55796 char *buff = ndoc;
55797 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55798 if (ptr) {
55799 strncpy(buff, methods[i].ml_doc, ldoc);
55800 buff += ldoc;
55801 strncpy(buff, "swig_ptr: ", 10);
55802 buff += 10;
55803 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55804 methods[i].ml_doc = ndoc;
55805 }
55806 }
55807 }
55808 }
55809 }
55810 }
55811
55812 #ifdef __cplusplus
55813 }
55814 #endif
55815
55816 /* -----------------------------------------------------------------------------*
55817 * Partial Init method
55818 * -----------------------------------------------------------------------------*/
55819
55820 #ifdef __cplusplus
55821 extern "C"
55822 #endif
55823 SWIGEXPORT void SWIG_init(void) {
55824 PyObject *m, *d;
55825
55826 /* Fix SwigMethods to carry the callback ptrs when needed */
55827 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55828
55829 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55830 d = PyModule_GetDict(m);
55831
55832 SWIG_InitializeModule(0);
55833 SWIG_InstallConstants(d,swig_const_table);
55834
55835
55836
55837 #ifndef wxPyUSE_EXPORT
55838 // Make our API structure a CObject so other modules can import it
55839 // from this module.
55840 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55841 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55842 Py_XDECREF(cobj);
55843 #endif
55844
55845 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55846 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55847 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55848 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55849 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55850 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55851 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55852 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55853 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55854 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55855 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55856 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55857 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55858 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55859 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55860 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55861 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55862 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55863 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55864 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55865 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55866 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55867 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55868 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55869 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55870 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55871 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55872 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55873 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55874 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55875 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55876 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55877 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55878 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55879 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55880 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55881 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55882 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55883 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55884 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55885 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55886 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55887 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55888 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55889 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55890 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55891 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55892 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55893 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55894 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55895 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55896 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55897 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55898 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55899 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55900 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55901 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55902 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55903 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55904 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55905 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55906 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55907 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55908 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55909 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55910 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55911 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55912 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55913 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55914 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55915 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55916 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55917 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55918 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55919 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55920 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55921 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55922 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55923 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55924 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55925 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55926 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55927 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55928 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55929 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55930 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55931 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55932 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55933 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55934 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55935 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55936 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55937 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55938 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55939 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55940 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55941 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55942 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55943 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55944 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55945 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55946 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55947 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55948 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55949 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55950 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55951 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55952 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55953 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55954 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55955 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55956 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55957 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55958 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55959 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55960 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55961 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55962 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55963 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55964 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55965 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55966 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55967 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55968 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55969 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55970 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55971 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55972 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55973 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55974 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55975 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55976 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55977 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55978 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55979 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55980 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55981 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55982 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55983 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55984 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55985 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55986 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55987 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55988 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55989 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55990 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55991 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55992 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55993 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55994 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55995 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55996 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55997 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55998 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55999 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56000 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56001 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56002 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56003 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56004 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56005 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56006 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56007 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56008 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56009 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56010 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56011 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56012 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56013 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56014 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56015 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56016 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56017 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56018 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56019 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56020 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56021 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56022 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56023 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56024 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56025 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56026 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56027 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56028 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56029 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56030 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56031 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56032 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56033 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56034 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56035 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56036 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56037 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56038 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56039 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56040 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56041 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56042 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56043 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56044 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56045 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56046 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56047 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56048 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56049 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56050 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56051 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56052 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56053 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56054 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56055 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56056 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56057 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56058 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56059 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56060 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56061 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56062 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56063 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56064 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56065 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56066 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56067 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56068 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56069 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56070 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56071 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56072 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56073 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56074 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56075 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56076 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56077 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56078 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56079 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56080 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56081 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56082 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56083 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56084 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56085 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56086 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56087 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56088 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56089 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56090 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56091 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56092 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56093 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56094 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56095 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56096 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56097 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56098 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56099 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56100 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56101 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56102 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56103 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56104 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56105 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56106 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56107 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56108 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56109 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56110 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56111 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56112 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56113 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56114 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56115 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56116 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56117 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56118 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56119 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56120 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56121 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56122 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56123 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56124 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56125 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56126 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56127 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56128 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56129 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56130 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56131 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56132 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56133 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56134 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56135 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56136 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56137 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56138 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56139 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56140 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56141 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56142 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56143 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56144 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56145 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56146 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56147 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56148 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56149 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56150 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56151 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56152 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56153 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56154 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56155 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56156 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56157 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56158 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56159 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56160 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56161 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56162 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56163 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56164 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56165 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56166 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56167 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56168 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56169 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56170 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56171 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56172 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56173 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56174 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56175 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56176 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56177 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56178 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56179 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56180 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56181 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56182 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56183 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56184 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56185 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56186 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56187 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56188 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56189 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56190 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56191 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56192 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56193 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56194 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56195 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56196 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56197 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56198 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56199 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56200 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56201 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56202 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56203 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56204 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56205 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56206 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56207 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56208 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56209 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56210 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56211 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56212 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56213 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56214 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56215 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56216 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56217 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56218 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56219 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56220 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56221 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56222 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56223 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56224 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56225 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56226 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56227 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56228 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56229 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56230 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56231 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56232 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56233 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56234 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56235 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56236 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56237 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56238 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56239 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56240 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56241 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56242 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56243 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56244 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56245 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56246 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56247 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56248 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56249 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56250 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56251 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56252 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56253 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56254 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56255 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56256 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56257 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56258 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56259 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56260 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56261 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56262 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56264 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56265 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56266 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56271 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56272 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56273 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56274 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56275 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56276 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56277 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56278 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56279 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56280 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56281 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56282 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56283 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56284 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56285 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56286 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56287 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56288 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56289 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56290 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56291 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56292 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56293 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56294 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56295 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56296 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56297 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56298 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56299 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56300 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56301 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56302 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56303 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56304 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56305 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56306 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56307 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56308 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56309 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56310 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56311 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56312 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56313 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56314 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56315 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56316 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56317 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56318 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56319 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56320 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56321 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56322 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56323 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56324 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56325 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56326 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56327 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56328 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56329 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56330 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56331 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56332 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56333 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56334 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56335 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56336 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56337 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56338 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56339 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56340 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56341 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56342 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56343 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56344 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56345 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56346 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56347 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56348 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56349 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56350 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56351 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56352 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56353 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56354 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56355 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56356 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56357 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56358 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56359 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56360 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56361 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56362 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56363 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56364 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56365 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56366 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56367 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56368 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56369 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56370 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56371 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56372 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56373 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56374 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56375 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56376 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56377 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56378 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56379 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56380 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56381 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56382 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56383 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56384 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56385 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56386 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56387 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56388 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56389 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56390 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56391 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56392 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56393 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56394 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56395 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56396 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56397 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56398 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56399 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56400 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56401 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56402 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56403 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56408 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56409 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56410 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56411 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56412 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56413 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56414 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56415 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56416 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56417 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56418 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56419 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56420 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56421 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56422 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56423 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56424 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56425 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56426 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56427 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56428 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56429 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56430 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56431 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56432 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56433 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56434 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56435 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56436 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56437 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56438 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56439 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56440 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56441 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56442 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56443 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56444 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56445 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56446 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56447 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56448 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56449 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56450 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56451 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56452 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56453 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56454 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56455 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56456 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56457 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56458 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56459 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56460 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56461 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56462 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56463 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56464 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56465 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56466 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56467 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56468 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56469 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56470 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56471 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56472 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56473 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56474 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56475 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56476 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56477 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56478 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56479 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56480 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56481 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56482 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56483 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56484 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56485 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56486 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56487 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56488 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56489 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56490 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56491 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56492 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56493 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56494 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56495 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56496 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56497 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56498 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56499 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56500 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56501 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56502 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56503 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56504 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56505 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56506 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56507 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56508 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56509 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56510
56511 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56512
56513
56514 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56515
56516 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56517 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56518 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56519 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56520 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56521 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56522 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56523 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56524 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56526 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56527 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56528 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56529 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56530 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56531 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56532 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56533 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56534 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56535 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56536 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56537 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56538 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56539 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56540 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56541 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56542 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56543 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56544 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56545 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56546 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56547 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56548 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56549 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56550 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56551 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56552 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56553 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56554 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56555 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56556 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56557 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56564 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56565 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56566 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56567 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56568 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56569 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56570 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56571 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56572 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56573 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56574 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56575 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56576 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56577 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56578 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56579 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56580 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56581 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56582 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56583 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56584 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56585 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56586 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56587 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56588 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56589 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56590 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56591 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56592 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56593 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56594 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56595 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56596 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56597 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56598 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56599 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56600 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56601 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56602 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56603 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56604 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56605 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56606 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56607 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56608 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56609 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56610 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56611 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56612 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56613 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56614 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56615 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56616 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56617 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56618 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56619 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56620 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56621 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56622 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56623 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56624 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56625 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56626 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56627 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56628 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56629 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56630 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56631 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56632 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56633 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56634 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56635 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56636 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56637 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56638 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56639 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56640 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56641 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56642 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56643 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56644 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56645 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56646 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56647 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56648 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56649 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56650 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56651 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56652 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56653 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56654 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56655 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56656 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56657 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56658 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56659 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56660 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56661 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56662 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56663 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56664 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56665 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56666 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56667 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56668 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56669 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56670 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56671 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56672 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56673 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56674 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56675 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56676 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56677 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56678 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56679 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56680 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56681 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56682 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56683 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56684 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56685 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56686 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56687 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56688 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56689 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56690 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56691 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56692 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56693 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56694 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56695 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56696 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56697 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56698 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56699 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56700 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56701 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56702 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56703 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56704 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56705 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56706 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56707 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56708 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56709 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56710 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56711 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56712 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56713 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56714 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56715 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56716 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56717 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56718 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56719 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56720 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56721 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56722
56723 // Initialize threading, some globals and such
56724 __wxPyPreStart(d);
56725
56726
56727 // Although these are defined in __version__ they need to be here too so
56728 // that an assert can be done to ensure that the wxPython and the wxWindows
56729 // versions match.
56730 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56731 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56732 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56733
56734 }
56735
wxWidgets (Impactor)